TypeScript vs J
When comparing TypeScript vs J, the Slant community recommends TypeScript for most people. In the question“What are the best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages?” TypeScript is ranked 26th while J is ranked 46th. The most important reason people chose TypeScript is:
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.
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 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 Strong typed language
Lot of benefits of it, you can read this.
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 editors (Sublime, Code, Vim, IntelliJ...)
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 Clear roadmap
TypeScript has a clear and defined roadmap with rapid and constant releases.
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 Works well with Angular 2
Angular 2 is built using TypeScript and applications built using it can make use of that (or not).
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 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 existing Javascript code
Both can call Javascript code and be called by Javascript code. Making transitioning to the language very easy.
Pro Great support for React, integrated typed JSX parsing
Strongly typed react components, so UI "templating" automatically gains type safety.
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 Ability to do functional programming
Pro Every function is an operator
3 classes of operators (verbs, adverbs, and conjunctions) with verbs the most basic function that take either 1 or 2 (infix) parameters. Operators allow function composition with a minimum of parentheses.
Pro Simpler Imperative language constructs as failback to functional programming
J also supports multiline functional definitions similar to BASIC/Pascal. Including error handling.
Pro Compiled language speed from interpreted language.
Each built in operator is a C/asm function, and special code further optimizes some operator combinations. Result is optimized C speed from quick parsing. Array orientation parses and compiles a function once, and applies it to all array items.
Pro 25 year old language, with core unchanged in last 10 years
Still actively developed, but most recent changes have been in libraries and IDE and platform support.
Language is considered "perfected"... though not quite.
Pro Language reference has simple one page index
Complete core programming functional tools allow writting programs and libraries without imports.
Pro No operator precedence rules
(... within each of the 3 operator classes) makes reading code easier. Very simple parsing rules.
Cons
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 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 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 Far less typed libraries than Dart (and TSD are never up to date).
Just compare https://pub.dartlang.org/packages and http://definitelytyped.org/tsd/
Typescript => 930
Dart => 2060
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 Benefits don't exceed costs
It is rather unnecessarily complicated for experienced JavaScript developers.
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 Syntax is pure madness
quicksort=: (($:@(<#[), (=#[), $:@(>#[)) ({~ ?@#)) ^: (1<#)