I’ve yet to see a JS IDE work like Smalltalk/Forth/Factor/etc in the sense that you edit with respect to the current memory image of the interpreter.

Hibberd, static languages with optional types differ somewhat from dynamic languages with optional types. With static languages that include type inferencing, like those based on ML, you omit type declarations, but you do not forfeit strong typing nor performance. Methods without types merely become parametric.

For example,

add(x, y) = x + y

If called as add(1,2) it compiles as add(int,int), if called with add(1.2, 2.3) it compiles as add(double,double), and if called with add(1.2, “Foo”) it throws a compile error because in this case, the intrinsic “+” operator doesn’t support (int,String) are parameters.

To extend my previous wish, I think AS3 and JS could almost be merged in the IDEs. A “show types” option could work in either AS3 (optional hiding) or JS (optional showing).

The language that really gets me is groovy. Not only does it have optional types. If you use them, the code is slower and they do not get checked up front so you can still assign ‘Bar b = new Foo()’ even if they are totally incompatible, it will then fail at runtime at the same place it would have without the type.

…try Screw-Unit for JavaScript BDD… if you like RSpec for Ruby, you’ll like it:

http://github.com/nkallen/screw-unit/tree/master
http://github.com/nkallen/screw-unit/tree/master/README.markdown

I would like to see this taken further and have my view on top of the data, which can be tweaked. E.g. I can set my brace style and even if it is different from the code, I see it how I like it. This fits into the same problem.

I like Nosredna’s suggesting. Allow the IDE a “hidden types” mode where you don’t see the declarations. Come to think of it, they could do this for Java as well in many cases. I proposed something similar in the Java Closures debate, which is implement a Java IDE extension which shows BGGA Closures as Anonymous Inner Classes for those who prefer more verbosity.

I think choice is best. I’m surprised that many people want to take away choice from others based on their own personal aesthetic preferences.

On the performance side of typing, the conclusion does not follow from the evidence. That is, the fact that adding an int type annotation caused a performance regression in Adobe’s VM implementation, does not mean that type information always leads to poorer performance vs a trace-jit, nor does it mean that the regressions would happen on every VM implementation that leverages type information. There is no a priori reason why a tracing-jit could not also leverage type information as well.

Optimizers are often brittle, and some perturbations cause large regressions. We see this in every language, and you will see it in Tracing JavaScript VMs, that certain constructs will thwart optimizations, which will lead to lots of guides like “How to write optimal Javascript for Tracing JITs”

There are many reasons why types help:

1) performance. Java Hotspot has some characteristics of a trace JIT, more in the vein of the original Self implementation, collecting type feedback and profile information to yield speculative optimizations with guards. It would be instructive to compare JS trace-jits not just against Tamarin, but against Silverlight CLR and JavaFX. Tracing JITs are being oversold. It’s true they are a massive improvement, but they are not going to be winning any language performance shootouts against statically compiled languages. HotSpot was oversold (as was Self) when originally released. Proponents were citing scenarios where it would beat C, but the reality is, it still doesn’t.

2) IDE toolchain. Navigating large code bases and doing safe refactorings are just alot easier to do with types. Types don’t make sense if you’ve only got 100 lines of code, but if you’re “programming in the large” with libraries containing hundreds or thousands of functions, it makes alot of sense. The lack of a standard package/module/namespace system in JS is a crime.

3) Self documenting. The types provide the ability to automatically generate mostly useful documentation, as well as allow programmers to quickly check expectations.

4) “on the wire size”. Trace JITs can help performance, but the optimizations can only be applied *after* the application has been downloaded. With people delivering JS code bases in upwards of 500k, the lack of a package/module system with early binding makes it hard to design preprocessors that strip unused code from the script. GWT, for example, shows how awesome this can become, reducing code size by a factor of 100 in some cases. The result is that everyone roles their own module/build system for concatenating scripts, and inter-library reuse and packaging is reduced.

I personally find that I can deal with missing types for small code bases, but when you get to something like a Google Spreadsheets or GMail app, the lack of types really starts to inhibit productivity. And I would assume that Google agrees, otherwise they would have never built their Javascript compiler, and you would not see /*type*/ stuff showing up in their idiomatic Javascript libraries.

When you see people putting semantically functional data in code comments, it tends to indicate a flaw in the language.

It matters a lot when you start to talk about more expressive applications and experiences (including 3d). Just ask the papervision 3d guys:

http://blog.papervision3d.org/category/demos/

>It will matter less and less in the future.

My experience working in the Flash community over the years is that to more processing power there is, the more developers and designers will push the boundry of what has been possible. Again, papervision 3d is a good example. It is a complete 3d engine implimented entirely in ActionScript, as is some of the image processing stuff (PNG, JPG encoding) made possible due to performance improvements in AS3.

But yes, for run of the mill apps, with buttons and forms, there is only so much processing power you need. Although, even in that case, more processing power and performance means that you can deal with much larger data sets, and do more advanced data manipulations.

mike chambers

mesh@adobe.com