7 ms·

...ships in 2020? I'm impressed with what they're doing (and love the language), and it's hard work, and their speed is faster than, say, Java's dead-pace evol

...ships in 2020? I'm impressed with what they're doing (and love the language), and it's hard work, and their speed is faster than, say, Java's dead-pace evolution in the 2000s. But, poking around at TypeScript, I've been blown away with the MS/TS speed of development. ~2-3 month release cycles, with non-trivial changes to the language (mapped types, conditional types, etc.), that are themselves unique/novel type system features, not like Java finally getting around to copying the obvious/best-practice approach to case/data classes. Granted, I'm sure the MS/TypeScript budget is huge comparatively... Seems like that's the "best" (realistic) way for dev tooling to evolve lately: come from, or attach yourself to, a ~top-5 tech company that makes their money somewhere else and can bankroll developer tools/languages (e.g. MS with TS, FB with React/Flow, Google with a myriad of things e.g. Dart & AdWords, Go). Bringing it back to Scala, seems like they were close to this (flirted with adoption/sponsorship from a few startups like FourSquare, etc.) but, thinking about it now, "software development in the large" is a huge concern for those companies (e.g. anyone with enough extra money to actually pay for language/tooling improvements), and that's never really been Scala's strong suit (compile times, painless compiler upgrades).

manojlds 8y ago
It's not the next release. There is 2.13 and 2.14 to be released. Are you saying Typescript has major version release every 3 months?
- actsasbuffoon 8y ago
  Typescript does indeed do frequent releases, though they're not nearly as ambitious as Scala 3.0. A Typescript release usually has 1-3 exciting new features, and a number of smaller bug fixes and improvements.
  - benjaminjackman 8y ago
    Correct, but collectively, between now and 2020 it's almost certain in aggregate, Typescript will have significantly more `features` than Scala 3.0, and they will have the benefit of being used and iterated upon for 2+ years.
    - coryfklein 8y ago
      Like many things, the utility of a language can actually decrease as you add more things on to it. Both Scala and Go take a principled approach of only accepting heavily vetted features. The time it takes to develop a feature is very rarely the bottleneck.
    - threeseed 8y ago
      There are developer releases through 2019 as well. So it's not like it won't be used until 2020.
cinnamonheart 8y ago
For what it's worth, this isn't just an evolution of the language, but a complete rewrite of the compiler. I appreciate that they're taking the time to do it right. They probably could've pushed new, non-trivial features out faster if they weren't doing a total rewrite.
- BurningFrog 8y ago
  This does nothing to change my opinion that total rewrites are almost always a horrible idea.
  - pas 8y ago
    The Scala compiler has to be cleaned up. Maybe rewritten, maybe not. Dotty started as a fork of Scala, and now Odersky decided/announced that it'll be merged back eventually. (And it should conform to whatever the Scala language is/will be after the SIP processes for 3.0.)
  - JoeAltmaier 8y ago
    The old saying: "Its bigger and slower, but at least its more expensive!" My experience says, a rewrite just has different bugs. Combined with delay and cost, its often not worthwhile.
  - ionforce 8y ago
    I've never seen a system or project that's had a "big" change that wasn't always a total rewrite. I guess it's always envisioned differently like "can we tackle this subsystem in isolation".
- Blaisorblade0 8y ago
  Scalac has evolved considerably, but it appears to be much harder to evolve. The Scalac team and contributors are backporting some of the Dotty features, but this is far from a trivial effort. Doing the same changes in Dotty is typically much easier in comparison.
- hota_mazi 8y ago
  Pity that in this rewrite, they were unable to speed up compilation speed. From the latest reports, dotty appears to compile at about the same speed (if not more slowly than) scalac.
bad_user 8y ago
> I've been blown away with the MS/TS speed of development TypeScript broke my code for the past year on every new release. --- Scala evolves a lot on each new version. There's a big difference between 2.10 and 2.12, the current version. Dotty is a big change. That it ships in 2020 that's OK. Shipping it any sooner is risky.
munificent 8y ago
TypeScript has a comparatively easier job because the type system is unsound. They can add new type features without needing to be paranoid about a hole in the system or a usability pitfall because the tools don't rely on types for correctness or optimization, and because users can easily cast to "any" or otherwise work around an annoyance. When you want the whole system to actually deeply rely on the static type system, it needs to be much more robust, and that takes a lot of effort. I'm not trying to minimize what the TypeScript folks are doing — it's a really nice, well-designed language. But the complexity required to evolve an optionally-typed language is closer to that of a dynamically-typed one than a statically-typed one.
- naasking 8y ago
  Is it actually unsound if you perform no casting? That seems to be a more interesting property, because then the additions they're making still have to mesh cohesively.
  - raquo 8y ago
    Yes, look at how it deals with type param variance for example. It doesn't.
  - munificent 8y ago
    > Is it actually unsound if you perform no casting? Yeah, it is. At the very least, I know that function parameters are bivariant, which isn't sound: function foo(callback: (obj: Object) => void) { callback("not a bool"); } function main() { foo(function (bool: Boolean) { if (bool) window.console.log("!"); }); } This compiles without a type error but ends up assigning a string to a parameter of type bool.
    - ItsMe000001 8y ago
      I'm a Flow user rather than TS (and Flow complains about that code out of the box), but you are not telling us all: Since TS 2.6, if you enable all the optional "strict" mode checks than TypeScript does complain about that code. I see no disadvantage in those checks, e.g. "strictFunctionTypes", being optional, since you can always make them mandatory for your own project(s). To test it: - Go to the TS Playground at https://www.typescriptlang.org/play/ https://www.typescriptlang.org/play/ - Enter the above code - Select "Options" and enable at least "strictFunctionTypes"
vbezhenar 8y ago
That's my negative point about Kotlin (sorry, offtopic here, but stil). It moved fast before release and now for a long time there were only very minor releases (well, coroutines were nice addition and that's all) despite the fact that there's a lot to improve in Kotlin.

manojlds 8y ago

It's not the next release. There is 2.13 and 2.14 to be released. Are you saying Typescript has major version release every 3 months?

actsasbuffoon 8y ago
Typescript does indeed do frequent releases, though they're not nearly as ambitious as Scala 3.0. A Typescript release usually has 1-3 exciting new features, and a number of smaller bug fixes and improvements.
- benjaminjackman 8y ago
  Correct, but collectively, between now and 2020 it's almost certain in aggregate, Typescript will have significantly more `features` than Scala 3.0, and they will have the benefit of being used and iterated upon for 2+ years.
  - coryfklein 8y ago
    Like many things, the utility of a language can actually decrease as you add more things on to it. Both Scala and Go take a principled approach of only accepting heavily vetted features. The time it takes to develop a feature is very rarely the bottleneck.
  - threeseed 8y ago
    There are developer releases through 2019 as well. So it's not like it won't be used until 2020.

cinnamonheart 8y ago

For what it's worth, this isn't just an evolution of the language, but a complete rewrite of the compiler. I appreciate that they're taking the time to do it right. They probably could've pushed new, non-trivial features out faster if they weren't doing a total rewrite.

BurningFrog 8y ago
This does nothing to change my opinion that total rewrites are almost always a horrible idea.
- pas 8y ago
  The Scala compiler has to be cleaned up. Maybe rewritten, maybe not. Dotty started as a fork of Scala, and now Odersky decided/announced that it'll be merged back eventually. (And it should conform to whatever the Scala language is/will be after the SIP processes for 3.0.)
- JoeAltmaier 8y ago
  The old saying: "Its bigger and slower, but at least its more expensive!" My experience says, a rewrite just has different bugs. Combined with delay and cost, its often not worthwhile.
- ionforce 8y ago
  I've never seen a system or project that's had a "big" change that wasn't always a total rewrite. I guess it's always envisioned differently like "can we tackle this subsystem in isolation".
Blaisorblade0 8y ago
Scalac has evolved considerably, but it appears to be much harder to evolve. The Scalac team and contributors are backporting some of the Dotty features, but this is far from a trivial effort. Doing the same changes in Dotty is typically much easier in comparison.
hota_mazi 8y ago
Pity that in this rewrite, they were unable to speed up compilation speed. From the latest reports, dotty appears to compile at about the same speed (if not more slowly than) scalac.

bad_user 8y ago

> I've been blown away with the MS/TS speed of development TypeScript broke my code for the past year on every new release. --- Scala evolves a lot on each new version. There's a big difference between 2.10 and 2.12, the current version. Dotty is a big change. That it ships in 2020 that's OK. Shipping it any sooner is risky.

munificent 8y ago

TypeScript has a comparatively easier job because the type system is unsound. They can add new type features without needing to be paranoid about a hole in the system or a usability pitfall because the tools don't rely on types for correctness or optimization, and because users can easily cast to "any" or otherwise work around an annoyance. When you want the whole system to actually deeply rely on the static type system, it needs to be much more robust, and that takes a lot of effort. I'm not trying to minimize what the TypeScript folks are doing — it's a really nice, well-designed language. But the complexity required to evolve an optionally-typed language is closer to that of a dynamically-typed one than a statically-typed one.

naasking 8y ago
Is it actually unsound if you perform no casting? That seems to be a more interesting property, because then the additions they're making still have to mesh cohesively.
- raquo 8y ago
  Yes, look at how it deals with type param variance for example. It doesn't.
- munificent 8y ago
  > Is it actually unsound if you perform no casting? Yeah, it is. At the very least, I know that function parameters are bivariant, which isn't sound: function foo(callback: (obj: Object) => void) { callback("not a bool"); } function main() { foo(function (bool: Boolean) { if (bool) window.console.log("!"); }); } This compiles without a type error but ends up assigning a string to a parameter of type bool.
  - ItsMe000001 8y ago
    I'm a Flow user rather than TS (and Flow complains about that code out of the box), but you are not telling us all: Since TS 2.6, if you enable all the optional "strict" mode checks than TypeScript does complain about that code. I see no disadvantage in those checks, e.g. "strictFunctionTypes", being optional, since you can always make them mandatory for your own project(s). To test it: - Go to the TS Playground at https://www.typescriptlang.org/play/ https://www.typescriptlang.org/play/ - Enter the above code - Select "Options" and enable at least "strictFunctionTypes"

vbezhenar 8y ago

That's my negative point about Kotlin (sorry, offtopic here, but stil). It moved fast before release and now for a long time there were only very minor releases (well, coroutines were nice addition and that's all) despite the fact that there's a lot to improve in Kotlin.