987 karma · joined March 2, 2013
Why don't you just recompile?
Suddenly, Dijkstra's insistence on developing the proof together with the program and providing it to any interested person doesn't seem to be the ridiculous idea that some people consider it to be, does it?
Trivially. Since virtually all currently used languages form syntactic trees (the exception being such beasts as Forth, Postscript etc.), you could use persistent data structures (which are trees again) for programs in these languages. Serializing the persistent data structure in a log-like fashion would be equivalent to working with a Git repository, only on a more fine-grained level. Essentially, this would also unify the notion of in-editor undo/redo and commit-based versioning; there would be no difference between the two at all. You'd simply tag the whole thing every now and then whenever you reach a development milestone.
You've never had an ECG done?
Thare's been a "dramatic change" between the 80's and 00's? If so, I must have missed it. I look at, say, IBM 1620 versus the machines designed in the 1980's, and that is change to me. In the 1980's, essentially everything we use now in the area of personal computing architectures has already been invented and put to use. Essentially, by the time you get to the 1980's, everything has been so homogenized and regularized that I really don't see anything new that happened since then.
Perhaps some change is going on now - AMD's hUMA seems to me to be the first major departure from the 1980's machine model in those twenty five years or so, but even then, I'm not sure how much is that "new" - IBM has had heterogenous CPUs on their mainframes for quite some time, so conceptually, it's just another idea getting to the PC world from the world of mainframes.
How could that possibly be true? What does "powerful" mean? Certainly not that it can compute things that APL family languages can't, and the design of APL/J/K etc. as languages is so much better that it isn't even fun. SQL is the COBOL for the 21th century.
Does the author understand that a just-in-time dynamically recompiling virtual machine is faster than an interpreter?
As memory latencies relative to instruction execution times go up, this factor becomes less and less relevant. An even worse problem is that your "just-in-time dynamically recompiling virtual machine" can't even vectorize properly, whereas APL has high-level array manipulating operators that make it comparatively easy to generate vectorized code. Your "just-in-time dynamically recompiling virtual machine" would have to "intelligently" recover high-level patterns from seemingly nondescript for() and while() loops to do that. Guess what: it doesn't! When you consider the fact that memory latencies matter these days, the fact that an AVX vector instruction can do a whole lot of work in a single cycle (or a few of them at most), and the fact that the integer units that would otherwise be idle can handle dispatching the next primitive operation in the meantime, there's a potential for even an interpreter to kick your "just-in-time dynamically recompiling virtual machine"'s ass.
So what? On what else than crime statistics do you propose to build a predictive system for crime? It doesn't matter which communities it picks as risky, people in those communities will scream "bloody murder" no matter what community we'd be talking about.
Exactly, this is for literrate people!
That's impossible; Discipline of Programming has only 217 pages of text. Surely you've been so enthralled by your reading that you didn't notice skipping through the covers to the book laying below!
...has always been the absorption of CO2 in the rocks of the Earth's crust. Or hasn't it? Well, this process is still working, but it won't be working for long, since there's almost no CO2 to absorb anymore.
Doesn't Erlang do something like this with processes?
What about doing scratch heaps for data with limited lifetime? Especially if you have a way of somehow reasonably predicting how much heap you're likely going to need (perhaps a heuristics obtained with a bit of machine learning?). Allocate a bit more to give yourself some headroom, use a dumb allocator, and if you run out of space, allocate an emergency area. Obviously, in most cases you won't have to do that, though. (If you're obsessed about speed, you can allocate just blindly and use a memory fault handler to detect that you've run out of space. :-) CLISP does that and it seems to work. Look at GNU libsigsegv.)
...on AMD machines, too? (Not to mention mobile development on ARM.)
LLVM is the lowest common denominator. I'm really not fond of lowest common denominators. (Not to mention the fact that it's bloatware in the first place - it's about twice the size of my favourite compiler, and that's before you add the actual language you're trying to compile.)
Really? Where? Which one? The last time I looked, TAL was only a proposal.
How does one do call/cc in LLVM, or delimited continuations, for that matter?
What about the overall success of http://www.open.ac.uk ? Apparently, distance learning is acknowleged by employers.
However, it's great for schizoid people who may not have the same options that you had.
It might have been one of the design goals, but it wasn't the ultimate design goal (which, I believe, was making a convergent compromise dialect to rule them all), otherwise certain parts of the language would have been most likely simpler. The things you mention are the good stuff. The problem is that there's also some bad stuff that hindered performance of CL on stock hardware until quality compilers were written. Yes, SBCL is quite fast. But you'd have a hard time trying to convince me that even modern implementations of Common Lisp represent some sort of performance optimum in the same way that, say, Stalin Scheme represents an optimum.
Also, wouldn't TAGBODY/GO be replaceable in presence of proper tail recursion by structuring the "TAGBODY basic blocks" into mutually recursive function calls? The same argument could be applied to inlining: Yes, the Common Lisp standard mentions inlining. But did you notice how nowadays, that's more or less considered an implementation issue rather than a language issue? How JVMs are capable of inlining just fine without having to be hinted what to inline and what not to inline?
Now I'd understand some of the hints, perhaps DYNAMIC-EXTENT makes somewhat more sense if the purpose is to say "It's my intent to create this value for a limited period of time, yell at me if I pass it out", but in general, from where I stand, a lot of the design decisions seem to make writing Common Lisp compilers actually more complicated to modern compiler writers.
Gambit-C is one of the fastest Lisp implementations around, and it does have a full and performant implementations of call/cc. And I'm afraid that Common Lisp happens to be "fast by sccident" rather than "fast by design" - there's probably more extra speed to be gained by having a better implementable standard (which CL isn't, or at least not that much) than by omitting call/cc.
(Also note that call/cc is sort of out of favour these days, delimited continuations is where it's at.)
So why are Lisp and Smalltalk, which are equally dynamic and reflective, even faster?