
TypeScript Roadmap 2019 - Vinnl
https://github.com/Microsoft/TypeScript/issues/29288
======
finchisko
I dream about typescript becoming statically compiled language. Or hybrid
language similar to dart and flutter, which in dev mode is interpreted for
fast reload times and in production it gets compiled to native code.

~~~
austincheney
It is only statically compiled. You run the _tsc_ command to compile the
TypeScript code to JavaScript output.

~~~
frontfor
I think the OP meant that it should compile to native code, which is not
supported today.

------
z3t4
Most people do not care about types, they care about smart intellisense and
detecting errors such as a misspelled property.

~~~
austincheney
I disagree. Perhaps I am in the minority on this, I don't know. I care about
types and don't care about intellisence. I write lots of atomic algorithms
that are super-independent, independent of each other but also compensating
for the changes by each other, and make heavy use of scope. It is very
important to my code that things execute efficiently and accurately.

~~~
z3t4
I do not understand what you mean. But it sounds like you are into functional
programming !? Which works fine without type annotations. For example:

const sum = (number, number) => number+number

Where type annotations becomes unnecessary verbose.

~~~
austincheney
True. Consider this example:

    
    
        props.removes[cc] !== props.last.margin
    

TypeScript's strict types will see the error if the those are not the same
data type. A TypeScript aware editor will yell at me before I compile the
code. Perhaps what I really wanted is:

    
    
        props.removes[cc][0] !== props.last.margin
    

In JavaScript I would have to execute the code. If the code doesn't throw an
error then I would have to examine the output to see if the resulting data
structure matches what I expect. If not I have to run tests and track down the
error. Then once the error is found and resolved I have to write unit tests
for this scenario.

~~~
z3t4
You can use an auto-generated intermediate format when running the tests, that
check each member object, give test coverage, etc. Eg. a tool that parses the
code and inserts a bunch of checks above each member access. So you start with
plain JavaScript, and you ship plain JavaScript.

