Add to Chrome
Add to Edge
Add to Firefox
Add to Opera
Add to Brave
Add to SafariTypeScript vs Gulp
When comparing TypeScript vs Gulp, the Slant community recommends Gulp for most people. In the question“What are the best plugins for Sublime Text?” Gulp is ranked 24th while TypeScript is ranked 34th. The most important reason people chose Gulp is:
Currently gulp offers a selection of 1000+ [plugins](http://gulpjs.com/plugins/) and it is growing rapidly.
Specs
Question Ranking
Pros
Pro Optional static typing
Typescript has optional static typing with support for interfaces and generics, and intelligent type inference.
It makes refactoring large codebases a breeze, and provides many more safeguards for creating stable code.
Pro Strong typed language
Lot of benefits of it, you can read this.
Pro Strict superset of Javascript
Every existing Javascript program is already a valid TypeScript program giving it the best support for existing libraries, which is particularly useful if you need to integrate with an existing Javascript code base.
Pro First party Visual Studio support
As a Microsoft developed project, it has first party Visual Studio support that's on par with its C# support with features like syntax sensitive statement completion.
Pro Has a repository of high quality TypeScript type definitions for popular libraries
There are many ready to use and high quality TypeScript definitions for popular libraries including jquery, angular, bootstrap, d3, lodash and many-many more.
Pro Adds support for object-oriented programming
Typescript enables familiar object-oriented programming patterns: classes, inheritance, public/private methods and properties, et cetera.
Pro Polyfill for ES6 fat-arrow syntax
Typescript implements the fat arrow syntax, which always maintains the current context for this and is a shorter/more convenient syntax than traditional function definition.
Pro Great support for React, integrated typed JSX parsing
Strongly typed react components, so UI "templating" automatically gains type safety.
Pro Great support for editors (Sublime, Code, Vim, IntelliJ...)
Pro Works well with existing Javascript code
Both can call Javascript code and be called by Javascript code. Making transitioning to the language very easy.
Pro Compiles to very native looking code
Compiles to simple looking Javascript making it easy to understand what is happening and learn the language (if you already know Javascript).
Pro Built and supported by Microsoft
Being built by Microsoft, TypeScript is much more likely than most other similar open-source projects to receive continued long-term support, good documentation, and a steady stream of development.
Pro Ability to do functional programming
Pro Clear roadmap
TypeScript has a clear and defined roadmap with rapid and constant releases.
Pro Low number of logical errors brought in by built-in type annotations
TypeScript's built-in type signatures allow developers to fully document interfaces and make sure that they will be correctly compiled. Therefore, cutting down on logical errors.
Pro Works well with Angular 2
Angular 2 is built using TypeScript and applications built using it can make use of that (or not).
Pro Large plugin ecosystem
Currently gulp offers a selection of 1000+ plugins and it is growing rapidly.
Pro Focuses on code instead of configuration
This depends on your style, but gulp is closer to the code, the actual execution isn't hidden by multiple layers and it's much easier to customize the build system without writing bloated modules. This also brings rather small configuration files.
Pro Allows creating task dependencies
Any task can be set to have other tasks as dependencies. The dependencies are specified through piping streams, and tasks run concurrently if they do not block in dependencies.
Pro It is possible to use projects that use streams without plugins
Since Gulp just uses streams at its core, you don't actually need a plugin wrapper to use a project that uses streams. If you use this approach, the you don't even have to worry about plugin maintenance at all, and get the bleeding edge updates as soon as they come out even if the plugin hasn't been updated. It also means if a project happens to not have a plugin, you don't need to write a new one, you can just use it as is.
Pro Streaming build system makes it easier to apply code transformations
In gulp, it's easy to pipe multiple steps together which you commonly need with build systems. For example, you may need to compile the javascript source files, then package them together, and then minify it. The streaming system makes this much easier.
Additionally, it improves performance since all operations are done in memory (compared to I/O operations) and avoids the need of unnecessarily compiling files (compared to Grunt that has to compile all files even if just one has changed).
Pro Chaining API that's simple and elegant
In Gulp, the transforms are performed through chains which makes it easier to understand the order of operations, and easier to modify it.
Pro Concurrency allows for high-speed perfomance
Because streams in Gulp use pipes to establish dependency order, they are parallel by default without having to rely on plugins or hacks.
Pro Minimizes disk operations for improved performance
Because Gulp is built using streams, it can store intermediate transformations in memory and defer writing to disk until the very end. This improves performance by not requiring expensive blocking disk operations for task dependencies.
Pro The configuration file is easily readable
Gulp's configuration file is actually very readable because it's actual JavaScript instead of a large file of JSON objects. The entry barrier is very low for developers who have never used a task runner before and it's API is very simple, with only 4 methods.
Pro Gulp modules are usable without Gulp
Because Gulp is built on top of the streaming API, you don't actually need gulp to use them. This could be helpful if you want to re-use those modules outside of gulp, possibly for testing, and using the same modules would be more consistent.
Pro Gulp tasks run from terminal
Cons
Con Too similar to Javascript
Presents some advantages compared to Javascript, but because it is designed to be a superset of Javascript, it means all the bad parts of Javascript are still present.
Con Type checking not enforced by default
You have to use compiler flags to make sure it catches flaws like usage of implicit any, etc.
Con Type inference coverage is incomplete
The default type when declaring and using a variable is any. For example, the following should break but does not:
function add(a:number) { return a + 1 }
function addAB(a, b) {return add(a) + b}
addAB("this should break but doesn't :(", 100)In order to avoid this, you have to declare type signatures for every variable or parameter or set the flag --noImplicityAny when running the compiler.
Con Requires "this" for field access
Even in cases were there is no ambiguity, you still have to use "this.fieldName" instead of just "fieldName".
Con Syntax is too verbose
Con No support for dead code elimination
Typescript compiler does not remove dead code from generated file(s), you have to use external tools to remove unused code after compilation. This is harder to achieve, because Typescript compiler eliminated all type information.
Con No support for conditional compilation
There is no clean way to have debug and release builds compiled from the same source, where the release version removes all debugging tools and outputs from the generated file(s).
Con Awful error messages
Comparing to Elm or Rust for example, TypeScript's error messages won't say you very much. For example if you change method of interface which your class implements it won't say your class have incorrect implementation. Instead it'll show error in usage of instances of class. In some cases it can spoil hours of your work trying to figure out why your parameters are incorrect.
Con Technical debt
As consequence of not enforcing type checking.
Con No Java-like package structure
If you prefer a Java-like approach of partitioning your code into different packages, the module system of typescript will confuse you.
Con Small community
Con No option to declare that a function throws errors
Con Dead
Gulp is dead, hasn't been updated in 4 years.
Con Rapidly changing API
While it's good that the gulp maintainers want the api to be as good as possible, it comes at the expense of stability. The upcoming gulp 4.0 release has another update to the way dependency management works which will require everyone to update their build scripts.
It also makes it hard to look up information on best practices as the best practices keep changing, making a lot of the blog posts and questions about gulp out of date.
Con You need to know some limitations that are not very intuitive
There are some features in Gulp which may not be very intuitive, or that otherwise should have been the default features instead of having to implement them through arguments. For example, to keep the correct folder structure when you are copying a file, you have to add {base: "lib/"} as an argument.
Con No incremental building
Con Not suited for big and complex apps
Writing gulpfile for complex app which consists of many source types is very cumbersome and flawy process. You'll know when you want to move to webpack.
