
Dart 1.5 - dboyd
http://news.dartlang.org/2014/06/dart-15-makes-it-easier-to-develop-for.html
======
luos
I tried dart just last week with dart IDE (1.4.3). It was good, much better
than javascript.

My observations: Installing dependencies was easy. Types help a lot. The IDE
is good but sometimes can not show the correct type or just shows dynamic, the
autocomplete is usable if you write `this.` . Usable for a modify-refresh
cycle but the attached chromium seems to be a little buggy (on xubuntu the
window is not correctly drawn). In-browser exceptions are a little cryptic to
read. Very similar syntax to java/c#. Good stdlib (I tried
async/browser/math). Little cumbersome calling JS but it works. Bult-in
factory pattern, setters/getters.

I think they could let users create multiline functions with the => operator
(currently only one line). :)

I tried to pub my code, but it did not work for some reasons. I haven't tried
since then so I don't know what kind of js it generates.

------
munificent
Hi! I'm on the Dart team. If you'd like, I'll try to answer any questions you
have.

~~~
lmkg
How well does Dart interact with JavaScript, especially libraries that are
asynchronously loaded? I know that the Dart compiler is a whole-program
optimizer, and I get the impression that Dart wants to own all the code on the
page.

In my line of work (web analytics), I have to use third-party JavaScript
libraries in order to integrate tools onto my page, like Adobe Analytics
(formerly Omniture SiteCatalyst) or IBM CoreMetrics or WebTrends. Fully
instrumenting a page generally involves wiring up other JavaScript on the page
with event handlers for web analytics functions (e.g. video
play/pause/progress, with video name & length as parameters).

Most analytics tools are also moving towards asychronously-loaded script-
injection techniques, like Adobe DTM or Ensighten. These usually include the
ability to selectively load relevant libraries, like only having video
tracking on video pages.

What's Dart's story for interacting with tools like that?

~~~
munificent
> How well does Dart interact with JavaScript, especially libraries that are
> asynchronously loaded?

I'm not the best person to ask about JS interop, but I know it's something
that other people on the team put a lot of effort into.

> I know that the Dart compiler is a whole-program optimizer, and I get the
> impression that Dart wants to own all the code on the page.

dart2js likes to have access to all of the _Dart_ code while it's compiling,
so it can do global optimization, but as far as I know, that doesn't affect JS
interop. Talking to JS is all dynamically dispatched at runtime, so the
compiler doesn't really care about it.

(We can also do deferred loading of Dart code now too, though I don't know the
details.)

> What's Dart's story for interacting with tools like that?

Beyond the general JS interop story, I don't know if we've done anything
specific there. I believe you should be able to talk to JS code even if it's
loaded much later.

------
ben336
Is anybody using Dart for significant production code outside of Google? (Not
mocking, genuinely curious to hear whats being done with it)

~~~
adrianlmm
I use Dart in production, it has its advatages like:

1.- It is better than JavaScript, is like using C# with a litle mix of Java.

2.- It comes with its own libraries, no more underscore.js or other patch
libraries that JS needs, it is already in the toolkit.

3.- It comes with the Dart Editor, where you can debug your code easily, for
scalable projects I find this to be invaluable.

4.- It will run in all your browsers, because it will export your code to
JavaScript, but not only export it, it will optimize it and will run really
fast.

5.- The pub library, go to pub.dartlang.org and you will find lots of packages
that you can install and use, like a bootjack, a bootstrap port in Dart.

There are prolly many more, but these are the ones that come to my head right
now.

But it also has its own problems like:

1.- No Dart support for Chrome yet and we don't know if there will ever be at
this point.

2.- The generated JavaScript will be huge, and I mean huge, mine is like 460k
per file and I'm not using polymer, when I used polymer the generated
JavaScript was over one megabyte, just insane in the cloud.

3.- Get use to regressions, with every point update I've have issues, I
upgraded from 1.4 to 1.5 two days ago, now my code is broken It runs, but it
will for example run futures twice, So I went back to 1.4 for now, I had some
other issues with UTF when migrating from 1.3 to 1.4 so, get use to.

4.- They are slow fixing bugs, looks like polymer and speed are their
priorities, but when you need something trivial that other languajes have had
for years and you report a bug it will get ignored, I've waited for 18 months
and my open bugs are not fixed yet.

I would say that Dart is nice and you should give it a chance.

~~~
u124556
Does it have anything like AngularJS?

~~~
spankalee
As mentioned already, there is AngularDart, but we also have a full port of
Polymer to Dart, so you can write web components in Dart.

[https://www.dartlang.org/polymer-dart/](https://www.dartlang.org/polymer-
dart/)

We also have Dart packages for the Polymer project's core-elements and paper-
elements (Material Design, nee Quantum Paper) that were announced at I/O.

[http://pub.dartlang.org/packages/paper_elements](http://pub.dartlang.org/packages/paper_elements)

Web components and Dart is a really powerful combination for apps.

------
msie
I was at last year's Google IO and a lot of people were asking the Dart
representatives about whether Dart was going to be supported in Chrome (not
just Chromium). We were told the team was holding off because of performance
considerations. It has been ONE WHOLE YEAR since then.

~~~
comex
Why do you want it to be supported in Chrome? Any performance improvements
seen by your users won't apply to those using any other browser.

~~~
Igglyboo
Because then his userbase goes from being an extremely small niche(chromium is
probably less than 1%) to a much larger niche(chrome is more than 30%).

~~~
rational-future
Do you mean that Chromium now has a Dart VM? The last time I checked it
didn't, there was a buggy thing called Dartium.

~~~
gsnedders
Dartium is still separate to Chromium.

------
stesch
I wouldn't use Dart until this bug is fixed:
[https://code.google.com/p/dart/issues/detail?id=13285](https://code.google.com/p/dart/issues/detail?id=13285)

~~~
jmesserly
fyi, I think most of my original complaints in that bug are either fixed, or
largely mitigated. I don't think we've had any issues for over a year now
(since Dart 1.0). I still wish it was even more bulletproof, but it isn't
scary anymore like it was. Google is building lots of stuff in Dart too, so
we're on the hook if something breaks.

~~~
stesch
Dart doesn't work correctly in Firefox 31 Beta. People will have to recompile
all their Dart apps next month.

~~~
jmesserly
Wow, seriously? I've been using Beta and not noticed any breakage (but that
doesn't mean there isn't any). Do you have any more context?

~~~
stesch
[https://code.google.com/p/dart/issues/detail?id=19489](https://code.google.com/p/dart/issues/detail?id=19489)

~~~
bzbarsky
Ouch. It looks like Dart is using Blink's IDL, not the spec IDL, for
generating bindings to JavaScript, so it's only really guaranteed to work in
Blink...

------
kasperset
I would like to use it but Javascript Frameworks and libraries are being
developed so rapidly that it gets difficult to choose Dart and plus it is yet
to mature. I may be wrong.

~~~
spankalee
Dart's been very stable for a while now, and has a really good library
ecosystem already.

Personally, I wouldn't worry too much about JavaScript frameworks evolving
rapidly, just go with anything the supports Web Components. In JavaScript that
would be Polymer, X-Tags or Bosonic. In Dart that's Polymer. Or, in either you
can write directly to the platform APIs without a library.

In my mind there is BWC and AWC: Before Web Components and After Web
Components. The world or web apps is undergoing a paradigm shift on par with
AJAX right now, and I wouldn't use any framework that doesn't support Web
Components.

~~~
kasperset
I have been looking at Polymer library and it looks promising.

------
laughfactory
I too would like to see a lot more work done on Dart web frameworks
(particularly client side) and a lot more documentation/tutorials
demonstrating non-trivial real applications which have a complex UI, data
binding, and talk to a database on the backend. Right now it's the dearth of
documentation/tutorials/books holding me back as I'm on the beginner end of
the spectrum--but still very interested in Dart.

------
Rapzid
Hello, golangs channels and go routines have been quite popular with some. So
popular that the clojure guys created core.async and even adopted the "go"
command(as a nod I'm assuming?). This works in the JVM via clojurescript.. Has
the Dart team considered such a system? Was it brought up when planning the
await stuff?

------
shakethemonkey
It would give me greater confidence if the first Dart example[1] on the
official Dart website did not point to a 404 Not Found.

[1] [https://www.dartlang.org/samples/](https://www.dartlang.org/samples/)

~~~
sethladd
Yikes! Not good. I just opened:
[https://code.google.com/p/dart/issues/detail?id=19708](https://code.google.com/p/dart/issues/detail?id=19708)

~~~
sethladd
I fixed our repo. The next time we push the site, it should be fixed. Thanks
for the report!

------
caycep
This may be a noob question on my part, but my understanding is Dart and Rust
are 2 separate efforts to come up with something to supplant javascript?

~~~
josteink
No. Rust is a systems language meant to displace c and c++.

Dart is Google's me-too attempt at creating something which compiles to
JavaScript. It borrows heavily from java and generates equally bloated code.

OK, so maybe last sentence is a bit over the top critical, but last I checked,
hello world in dart rendered in at 100kb [1] of js and dependencies.

[1] [http://lostechies.com/jimmybogard/2011/10/12/the-dart-
hello-...](http://lostechies.com/jimmybogard/2011/10/12/the-dart-hello-world/)

~~~
gsnedders
The aim of Dart was really to provide a second VM in browser with a
compatibility dart2js compilation mode. It was never intended to always be
used with dart2js.

Dart 1.5.1 produces nowhere near that much for the same input, producing just
14KB (see [1]). Yes, arguably still too verbose, but note that much of the
overhead is essentially a Dart-compatibility support library, so remains
constant as the amount of Dart increases.

[1]:
[https://gist.github.com/gsnedders/ab101d73bc91d2782e0a](https://gist.github.com/gsnedders/ab101d73bc91d2782e0a)

------
gress
Has this version been submitted to ECMA?

~~~
munificent
Yes: [http://news.dartlang.org/2014/02/standardizing-dart-1st-
ecma...](http://news.dartlang.org/2014/02/standardizing-dart-1st-ecma-
tc52.html)

------
dannyr
Anybody knows if there's a free DART PDF Book somewhere?

~~~
sethladd
Not sure about PDFs, but the text for Dart Up & Running can be found here:
[https://www.dartlang.org/docs/dart-up-and-
running/](https://www.dartlang.org/docs/dart-up-and-running/)

[disclaimer: I work for the Dart team, and I'm a coauthor of that book.]

------
pm90
How does dart compare to coffeescript?

~~~
munificent
This is a very simplified answer, but here's my take:

CoffeeScript says that the main problems with JS are the inelegant C-style
syntax and a few semantic trip wires. It addresses those while still keeping
the underlying semantics, APIs and ecosystem.

If what drives you up the wall about JS is stuff like the DOM, or JS's object
model, CoffeeScript won't help you much. If you are OK with how JS behaves and
like the very large JS ecosystem, CoffeeScript can be a nice fit.

Dart takes a much larger semantic step away from JS. Syntactically, it's more
similar to JS than CoffeeScript is. It sticks with braces and statements, and
the whole C kit and kaboodle.

However, semantically, it's much different. It has a full-featured class
system with inheritance, mixins, getters, setters, operator overloading, etc.
It has a static type system so you get the nice tooling experience you expect
from a language like Java or C#. It also completely revamps the DOM APIs to
(hopefully) be more rational, modern and consistent.

The cost, though, is that interacting with the existing JavaScript world is a
little more difficult. You can interop, of course, but it isn't as seamless as
CoffeeScript.

------
WorldWideWayne
I just don't trust Google to do languages and developer tools very well. They
don't seem to depend on developers enough to bend over backwards for us the
way that Microsoft does.

Plus, they seem to want to use web tech to build native desktop tools all the
time and little things like "keyboard acceleration" don't seem to matter to
them because there are no standards for that in web-world.

~~~
mythz
Not sure what you mean: MS has a history of abandoning its developer platforms
and frameworks that thier developers have invested in, so much so that there's
no longer a clear UI story for building native desktop windows apps, i.e. VB6,
Silverlight, WinForms and WPF are all effectively deprecated. Although they
have long support life, when they officially abandon a platform they also
refuse to Open Source it so others can keep it alive (e.g. VB6
[http://bit.ly/KPMUS6](http://bit.ly/KPMUS6)). I personally can't see how
anyone can put trust into building native Windows desktop apps (i.e. over web
apps) given the repeated a history of abandonment.

Even the #1 feature for VS.NET is to continue developing very popular XNA
framework: [http://visualstudio.uservoice.com/forums/121579-visual-
studi...](http://visualstudio.uservoice.com/forums/121579-visual-
studio/filters/top)

Likewise on the server side there's been history of deprecated frameworks a
lot of developers have invested a lot of energy into learning, e.g: .asmx,
CSF, WCF, WCF/REST, WSE, WCF DataServices, RIA

Whilst VisualStudio is a great IDE, I find it a subpar experience without R#.
The major advantages Dart has over C# is that it still provides an enjoyable
experience to develop even without an IDE which also includes support for the
most popular text editors:
[https://www.dartlang.org/tools/](https://www.dartlang.org/tools/) If you like
IDE and tooling support, the DartEditor offers a good experience with built-in
analyzer, debugging and refactoring support you can expect from a well
engineered language.

By contrast, C#'s configuration model, msbuild project format, heavy
frameworks and tooling makes it unfeasible to develop without an IDE.

The other major advantage Dart has is that it compiles down to JS where even
the compiler is completely self-hosting and runs inside a browser without
plugins: [http://try.dartlang.org/](http://try.dartlang.org/) Being able to
share the same code on client and server and having a single integrated
development full-stack experience is a huge win in re-usability and utility.

Another killer feature is that the language and tooling is cross-platform
which supports Windows, OSX and Linux. Something .NET devs often miss out on
is the value and utility of being able to host apps on cost-effective Linux
servers.

Google continues to invest a tonne of resources in Dart and Polymer which are
massive undertakings that are providing a much simplified and consistent
experience for developing large, complex web apps. Nothing like Dart or
Polymer exists. Dart is a platform that transpiles to JS, includes a native
Dart VM, an entire toolchain including IDE, analyzer and debugger both in Dart
Editor as well as in Chrome, in both the Dart VM as well as debugging with
Source maps.

The worlds best VM engineers work on the Dart VM, i.e. the same pedigree
responsible for the StrongTalk VM that was later acquired by Sun to form the
basis of the world-class Java Hotspot VM that later went on to develop V8, are
now leading the development on the Dart VM.

The excellence shows itself in the consistency and minimalism goals in the
language, providing a productive, iterative dynamic language experience for
fast prototyping with the benefit of static analysis with optional typing when
scaling up to a maintainable, well-documented code-base (best of both worlds).

Not only is Dart a productive dynamic language, it also has excellent
performance, the best performance of all languages I benchmarked with a port
of Peter Norvig's Sudoku solver:
[https://github.com/dartist/sudoku_solver#benchmarks](https://github.com/dartist/sudoku_solver#benchmarks)

~~~
seanmcdirmid
I'm feeling a little defensive here (disclaimer, MS employee, but I work for
MSR, not devdiv):

> Not sure what you mean: MS has a history of abandoning its developer
> platforms and frameworks that thier developers have invested in, so much so
> that there's no longer a clear UI story for building native desktop windows
> apps, i.e. VB6, Silverlight, WinForms and WPF are all effectively
> deprecated.

WPF is still chugging a long strongly even if there aren't so many new
features. Visual Studio was recently rewritten in it, and its a very good
design with lots of room for encoding desktop apps in the future. I use it
daily and cringe at the thought of ever doing something for the web without
it.

> Whilst VisualStudio is a great IDE, I find it a subpar experience without
> R#.

I use visual studio just fine without R#. I see no point these days writing
code without an IDE, I'm addicted to code completion. Not to mention amazing
things are being done with Roslyn.

> By contrast, C#'s configuration model, msbuild project format, heavy
> frameworks and tooling makes it unfeasible to develop without an IDE.

C# is totally usable from the command line, most developers just refer the
IDE.

> he worlds best VM engineers work on the Dart VM, i.e. the same pedigree
> responsible for the StrongTalk VM that was later acquired by Sun to form the
> basis of the world-class Java Hotspot VM that later went on to develop V8,
> are now leading the development on the Dart VM.

The CLR is one of the best VMs ever (read: very fast), worked on by some of
the brightest who are very comparable to the Animorphic crowd. The DLR feature
(ability to generate/compile expression trees at run-time) is also very cool
and missing from the JVM. If you are into building language run-times, it is
an awesome base for a dynamic language.

True: it is only available on Windows, but Mono has made progress as well
(most features available sans WPF). I've been thinking about porting my
language work [1] over to mono.cairo to see if I can achieve cross platform
without going to Java or the web.

[1] [http://research.microsoft.com/en-
us/people/smcdirm/liveprogr...](http://research.microsoft.com/en-
us/people/smcdirm/liveprogramming.aspx)

~~~
mythz
> WPF is still chugging a long strongly

Your definition of strong sounds different to other peoples. There was entire
FixWPF grass roots campaign to petition more investment into WPF, twitter
account is at: [https://twitter.com/fixwpf](https://twitter.com/fixwpf) they
also had a website and blog pleading for MS to keep investing in WPF and fix
its issues.

When and what was the most recent feature added to WPF?

> I see no point these days writing code without an IDE

You may not, but most popular languages can be developed without and IDE,
which is important for simplicity / deployment / portability. It's also much
easier to develop in smaller laptops which can maximize real-estate. Obviously
a language that is suitable without an IDE is also more suitable in an online
IDE, which we're seeing with the new online IDEs becoming available.

> C# is totally usable from the command line, most developers just refer the
> IDE.

So it's only usable where it's worst than most other languages at? i.e.
Scripts and Command-line apps? It's so totally usable that MS invented a new
completely different language for creating command-line scripts (PowerShell).

As you likely already know, most .NET developers don't spend their time
developing 1 file Console apps. Any task that has any meaningful user-share
requires an IDE.

> The CLR is one of the best VMs ever

Citation needed, it's not as performant as the JVM, and its lack of cross-
platform is a major limitation. The Sudoku benchmarks shows that it's slower
(and more verbose) than Dart even removing time spent on pre-compilation. Dart
also offers high-level productivity features like variable-sized integers,
saving a lot of boilerplate from having to deal with specific fixed-size
integers.

> awesome base for a dynamic language.

Really? All dynamic languages targetting both the CLR/JVM are either
deprecated or second-class citizens on the CLR and are always better supported
on the JVM: Jython/IronPython JRuby/IronRuby Clojure/ClojureCLR. The CLR is a
wasteland of unpolished efforts with relatively no traction/community behind
them.

The DLR team has actually been disbanded with the primary developer behind it
(Jim Hugunin / IronPython) having left Microsoft
([http://hugunin.net/microsoft_farewell.html](http://hugunin.net/microsoft_farewell.html))
to now work at Google on the Dart project no less.

What he had to say about Dart ([http://www.infoq.com/news/2011/11/dart-
roundup-frog](http://www.infoq.com/news/2011/11/dart-roundup-frog)):

    
    
        I've spent most of my career trying to end the battles between the dynamic 
        and static worlds and instead bring them together so that each side can 
        enjoy the benefits of the other. Writing this compiler in dart is the 
        first time that I've really felt the effortless blend of these worlds that 
        I've been seeking.
    
        Dart is the first time that I have been able to start off writing code in 
        a very dynamic fashion and incrementally add static checks as designs become 
        solid or complexity warrants the effort.
    

Dynamic itself is a heavyweight solution and may many suggest may have been a
mistake, C# 6.0 is actually introducing new '$' syntax to avoid dynamic and
make working with dictionaries better.

~~~
seanmcdirmid
> Your definition of strong sounds different to other peoples. There was
> entire FixWPF grass roots campaign to petition more investment into WPF,
> twitter account is at:
> [https://twitter.com/fixwpf](https://twitter.com/fixwpf) they also had a
> website and blog pleading for MS to keep investing in WPF and fix its
> issues.

WPF still works very well, it is not broken. It is still one of the best UI
toolkits ever constructed with a lot of flexibility that I don't think is
still appreciated enough.

> When and what was the most recent feature added to WPF?

No clue. I'm as curious as everyone else.

> You may not, but most popular languages can be developed without and IDE,
> which is important for simplicity / deployment / portability.

As far as I'm concerned, the IDE _is a part of the language_ and at the very
least the programming experience. People programming in emacs and VIM will
eventually retire, the future is undeniable at this point. A language designed
for an IDE will work better in an IDE than a language that is designed for
least common dominator development environments. But then I'm biased since
that is part of my research.

And also, Dart is so far very weak on the IDE side. I wonder if the Dart team
has lots of compiler people and not a lot of IDE people, or if they have the
same old-fashioned mindset as you in de-emphasizing the value of a good IDE
experience. But I would expect it to get better, they hired Luke Church after
all.

> It's so totally usable that MS invented a new completely different language
> written for creating command-line scripts (PowerShell).

PowerShell is an optional tool, not required. I've seen huge C# projects build
from a CMD prompt (not that I want to bother with build configuration
management myself).

> Citation needed, it's not as performant as the JVM

Citation needed, in my experience, C# kicks the JVM's butt in Win performance.
Reified generics also reduce lots of boxing issues.

> The Sudoku benchmarks shows that it's slower (and more verbose) than Dart

Your numbers are completely whack. First, it shows mono being faster than the
CLR, oh and you are using a virtual machine on top of that. Do you really
think people will take that seriously? Also, do you ever try..you know..a
multi-threaded shared memory solution?

> The DLR team has actually been disbanded with the primary developer behind
> it (Jim Hugunin / IronPython) having left Microsoft
> ([http://hugunin.net/microsoft_farewell.html](http://hugunin.net/microsoft_farewell.html))
> to now work at Google on the Dart project no less.

Jim and Jon are gone, but the work they did is totally still around and works
wonderfully. I use it, its fast, and it puts C# on par or beyond with any
dynamic language that supports dynamic eval.

> Dynamic itself is a heavyweight solution and may many suggest may have been
> a mistake, C# 6.0 is actually introducing new '$' syntax to avoid dynamic
> and make working with dictionaries better.

I'm not talking about C#'s dynamic language feature, which I don't really care
for, but dynamic expression tree compilation that came along with the rest of
the DLR. As a language implementer, it is very useful.

~~~
mythz
> WPF still works very well, it is not broken. It is still one of the best UI
> toolkits ever constructed

What exactly do you think the FixWPF campaign was about? And what else have
you used? If it's so good, why are so few Windows desktop apps that come with
Windows written with it? At least Apple uses Cocoa for all its OSX Desktop
apps which I find to be of much higher quality and has smoother performance.

> People programming in emacs and VIM will eventually retire, the future is
> undeniable at this point.

You're making it sound most developers using text editors are old kooks with
1-foot into retirement. How disconnected are you? What % of OSS projects on
GitHub do you think use an IDE? More or less than 50%?
[https://github.com/trending](https://github.com/trending)

> Dart is so far very weak on the IDE side. I wonder if the Dart team has lots
> of compiler people and not a lot of IDE people,

They actually have quite a few IDE people on the team with many years of
experience developing IDE tooling. Any immaturity is simply that the
DartEditor is still so young. It was only recently that they rewrote the old
Analyzer that was previously written in Java to Dart, which now runs much
faster. No doubt VS benefits from a large experienced IDE team as would
JetBrains.

> I've seen huge C# projects build from a CMD prompt

Seeing something done once doesn't extrapolate itself into a common use-case
or a well-supported story, which it isn't. Having to maintain your own build
scripts is a slow, painful and mundane experience which is why it's a rarely
considered approach. Even the just released Swift has a better command-line
story than C#, which supports #! scripts, a command-line REPL and LLVM
debugger.

> Citation needed, in my experience, C# kicks the JVM's butt in Win
> performance.

Citation is still needed. Where can this butt kicking be seen?

> Your numbers are completely whack. First, it shows mono being faster than
> the CLR, oh and you are using a virtual machine on top of that.

They're not my numbers, that's the actual output from the command-line Console
apps which you can see on the project page. But don't take my iMac's word for
it, all the source code is there, run the benchmarks yourself. Your 2 points
aren't exclusive, there is no "on top of that" they were all run from my iMac,
I would've run C#/.NET natively, but y'know that's hard to do when it's the
only platform that doesn't work cross-platform. Running inside Parallels
likely accounts for about 10-15% performance overhead, it doesn't explain 2.3x
worst performance.

> As a language implementer, it is very useful.

Language VM features that are optimal for compiler writers doesn't translate
itself into killer general-purpose language features for everyone else.

~~~
seanmcdirmid
> And what else have you used? If it's so good, why are so few Windows desktop
> apps that come with Windows written with it? At least Apple uses Cocoa for
> all its OSX Desktop apps which I find to be of much higher quality and
> smoother performance.

WPF is used for Visual Studio, and that is from VS 2010 on. WPF is used for a
lot of stuff internally, its not like people are still breaking out WinForms
or GDI. And then there is WP and WinRT, which are WPF derivatives.

> You're making it sound most developers using text editors are old kooks with
> 1-foot into retirement. How disconnected are you? What % of OSS projects on
> GitHub do you think use an IDE? More or less than 50%?
> [https://github.com/trending](https://github.com/trending)

GitHUB isn't even a small percentage of all developers, it only represents
public OSS projects. There is lots of value in a good IDE, language designers
and implementors who treat it as a second class concerns are going to pay the
price in popularity eventually.

> They actually have quite a few IDE people on the team with many years of
> experience developing IDE tooling. Any immaturity is simply that the
> DartEditor is still so young.

That isn't what I've heard. Anyways...Eclipse...wow...I don't see anything
good coming out of that.

> It was only recently that they rewrote the old Analyzer that was previously
> written in Java to Dart, which now runs much faster.

Fast tools mean nothing if the UX is crap. Also, incremental performance is
quite different from batch performance that you expect from the command line.

> Running inside Parallels likely accounts for about 10-15% performance
> overhead, it doesn't explain 2.3x worst performance.

In general, I've seen the CLR beat Mono anywhere from 1.5 to 3X. So if Mono is
coming up faster than the CLR, something is probably seriously off.

> Language VM features that are optimal for compiler writers doesn't translate
> itself into killer general-purpose language features.

Right. But it does give you lots of options in one's managed time live
programming language.

~~~
mythz
> WPF is used for Visual Studio, and that is from VS 2010 on. WPF is used for
> a lot of stuff internally

So neither that ships with Windows then?

> its not like people are still breaking out WinForms or GDI.

Do you think they've been overrun by developers breaking out WPF? Even when MS
is trying to push everyone into creating WindowsStore apps? I hardly ever see
any mainstream desktop apps written in WPF. What are some of the most popular
WPF apps developed outside of Microsoft?

> WP and WinRT, which are WPF derivatives

How can WinRT be a derivative of WPF if it's written in C++? What WPF code-
base did they derive from?

> GitHUB isn't even a small percentage of all developers,

So what does show a good measure of overall developers that shows the slow
death of languages/devs without IDE's?

> There is lots of value in a good IDE

There's also lots of value in small, wrist-friendly languages that don't need
an IDE and have a good story for text-editors / command-line. You may want to
check out what the dev story is for Clojure / Go / Node which support live-
reloading / auto-running of modified tests and fast dev iteration times
without IDE's.

~~~
seanmcdirmid
> How can WinRT be a derivative of WPF if it's written in C++? What WPF code-
> base did they derive from?

They derived WPFs design and API language, along with XAML. Its not like
MILCORE was written in C# either.

> So what does show a good measure of overall developers that shows the slow
> death of languages/devs without IDE's

It shows nothing. IDEs haven't really been a thing (they weren't that good
until then) since the late 90s or even mid 00s. It is taking awhile, but its
happening. We will see more language designs that don't bother with IDE
independence for better features. Couple that in with the Bret Victor candy,
and there is only one way to get there.

> There's also lots of value in small, wrist-friendly languages that don't
> need an IDE and have a good story for text-editors / command-line. You may
> want to check out what the dev story is for Clojure / Go / Node which
> support live-reloading / auto-running of modified tests and fast dev
> iteration times without IDE's.

I know all about those systems, and they aren't very inspiring. We can do much
better than that if we don't limit ourselves to languages just being
syntax/semantics/and a compiler.

~~~
mythz
> They derived WPFs design and API language, along with XAML. Its not like
> MILCORE was written in C# either.

Got it, so it's derivative in the same way Chrome is a derivative of IE
because HTML/CSS. Only a little less so due to different namespaces, missing
controls, completely different runtime and incompatible desktop modes -
maximizing developer happiness since 2011.

> It shows nothing. IDEs haven't really been a thing...

Not nothing, apparently it's enough to declare text-editor devs an extinct
species and decree the new generation of devs will skip text editors entirely
and only consider IDE-coupled languages.

> Couple that in with the Bret Victor candy, and there is only one way to get
> there.

Bret Victor showcases the benefits of previewing changes in real-time like the
kind you can see with Clojure in LightTable or Swift's playground. Late-bound
languages are more suitable for effecting real-time changes than static pre-
compiled IDE-coupled languages, the kind that was being done in Smalltalk
decades ago, even VB6 had better live-editing support than C#/VS.NET does now
with Edit/Continue.

~~~
seanmcdirmid
> Got it, so it's derivative in the same way Chrome is a derivative of IE
> because HTML/CSS. Only a little less so due to different namespaces, missing
> controls, completely different runtime and incompatible desktop modes -
> maximizing developer happiness since 2011.

WinRT really is WPF cleaned up a bit and done with a different language
(though it supports .NET bindings easily), and ya, missing a bunch of features
that even I sorely miss (though to be share, pixel shaders are kind of
dangerous!). Same people, same API architecture, same etc...I still prefer
WPF, but because I'm writing dev environments and not apps.

> Not nothing, apparently it's enough to declare text-editor devs an extinct
> species and decree the new generation of devs will skip text editors
> entirely and only consider IDE-coupled languages.

IDEs weren't a thing until recently (the last 15 or so years). Text-editor
devs aren't extinct, just shrinking in numbers. Extinction doesn't occur for
another 20 or so years. Anyways, you need IDE believers to make good IDEs, you
can tell when an IDE has been pushed out by non-believers (it sucks, because
they don't get it).

> Bret Victor showcases the benefits of previewing changes in real-time like
> the kind you can see with Clojure in LightTable or Swift's playground. Late-
> bound languages are more suitable for effecting real-time changes than
> static pre-compiled IDE-coupled languages, the kind that was being done in
> Smalltalk decades ago, even VB6 had better live-editing support than
> C#/VS.NET does now with Edit/Continue.

Why must an IDE-coupled language "static" or "pre-compiled"? I agree C# isn't
very live nor would I try to make it be live, but the CLR provides a lot of
the tools needed to get there (quick real-time tree compilation). I'm working
on this right now...(see [1] again if you haven't, and that's from last year).

Your standards of live editing are kind of low, but that's an argument for
some other time.

[1] [http://research.microsoft.com/en-
us/people/smcdirm/liveprogr...](http://research.microsoft.com/en-
us/people/smcdirm/liveprogramming.aspx)

~~~
dragonwriter
> IDEs weren't a thing until recently (the last 15 or so years).

IDEs originated in the 1970s, and became popular in the 1980s.

> Text-editor devs aren't extinct, just shrinking in numbers.

The line between "text editor" and "IDE" is so blurry now that there's
probably not a clear line between text editor devs and IDE devs. (And there's
plenty of multilanguage devs whose preference on the "editor-IDE" axis
probably varies by language -- certainly the level of tooling sophistication I
want with Ruby is different than I want with C# or Java.)

And more and more modern languages have both "doesn't need an IDE as much as
older static languages" and "can more easily support IDE tooling than older
dynamic languages" as features, so there's plenty of fuel for both sides. I
don't think the preference for lighter tooling is dying out.

