The symbol table, generated code etc. for every compilation unit is kept in memory and only discarded if the source is modified. All imports across compilation units are done via a double indirection, so the symbols can be unlinked and relinked more easily.
(Sub-second recompiles in Delphi are the norm, not the exception. In large projects, most of the time during dev builds is linking, and that's usually only a few seconds.)
Specially given Delphi features vs Go ones.
(I mention this in the context of my observation that the minimum bar to be taken seriously for a language is going steadily up. You certainly need a standard library that is powerful out of the gate, whether or not it is necessarily "part" of the language, and we're getting perilously close to the language being required to ship some heavy-duty HTTP stuff, possibly a server implemented in the language, before it stands a chance. Rust may have snuck in under the wire on that, though of course that stack is developing apace even so.)
Let the ecosystem provide, then, once there's a few clean winners, pick one as the official (while keeping the others there, obviously).
What is interesting is that I can't think of a lot languages that do it. It should be the default, as it's easy, safe, and gets good results. Somehow, it isn't.
And then there's the Haskell's way of: let the community informally choose the one best option, and when somebody uses any of the other ones, just get somebody near him telling "nobody goes there anymore, come to this other place". It works very well, but is a bit confusing for newbies.
Kind of, it supported distributed computing via CORBA and RMI.
A built in web server was released as part of Java 6, 2006.
> Can't speak to the other ones but I would imagine their first releases were also less useful than Go.
The fact is that Go, released in 2009, was a pretty bare bones compared to the state of those programming languages in 2009.
Also while Go might had an HTTP package on version 1.0, it surely still doesn't have a GUI framework on 1.8, which those languages had on 1.0.
EDIT: Rephrased a bit the answer.
Go isn't even that old yet. You're welcome to discuss what you like but I'm talking about what thing came with at first release.
"Also while Go might had an HTTP package on version 1.0, it surely still doesn't have a GUI framework on 1.8, which those languages had on 1.0."
Point. And even by 1.0 Java's was at least modestly capable by the standards of the time, as I recall. It didn't have everything, certainly couldn't compete with all the custom widgets you could buy for Windows, but usable.
Just in cases someone mentions NGEN, it is just intended to enable fast startups.
IDE power, the VCL, amazing documentation, rapid builds, clean OO language, it had it all.
It was a fantastic development environment even by modern standards but for its time it was well ahead of the curve.
I still try out Lazarus once in a while just for nostalgia :)
We are doing a project with a company that uses it for all their Windows applications.
Delphi conferences are still a thing in Germany.
http://www.dotnetcurry.com/csharp/1258/dotnet-platform-compi...
> Every time a developer changes a single character in any of the files, a new copy of all the data structures is created, leaving the previous version unchanged. This allows a high level of parallelism and concurrency in the Roslyn engine, as well as in its consumers, thereby preventing any race conditions to occur. Of course, in the interest of performance, these operations are highly optimized and reuse as much of the existing data structures as possible. Again, those being immutable makes this possible!
I first thought about this when working on UnderC, a hopelessly over-ambitious C++ interpreter. Functions could be recompiled, because there was an indirect reference to the actual code. And this is of course exactly how Lisp people used their compiler. (The 'image' reference of course is to Smalltalk)
[1] https://commandcenter.blogspot.co.za/2012/06/less-is-exponen...
The problem is, that usually this "keep state and just percolate changes" is easier said than done. But we're getting there.
See also:
https://www.youtube.com/watch?v=TS1lpKBMkgg#t=23m38s (scalac performance) https://www.youtube.com/watch?v=TS1lpKBMkgg#t=37m53s (what do we really need from "computing science" to do programming)
Even C++ had such tools in the past via Energize C++ and VisualAge for C++ v.40.
Microsoft is now kind of following this path with /fastlink and improved database backend for code metadata.
EDIT: Typo