

Convergence in Language Design (2006) [pdf] - zik
http://www.researchgate.net/publication/221278528_Convergence_in_Language_Design_A_Case_of_Lightning_Striking_Four_Times_in_the_Same_Place/file/3deec5278d108cb154.pdf

======
kaeluka
Oh, interesting. However, I'm disappointed to not find a comment on timing
critical systems. IMO, these systems favour imperative programming models with
explicit or ownership-based (C, rust, C++) memory management.

> This conﬁrms the importance of functional programming and message passing as
> important defaults

What is 'this'? Is it the result of cherry picking or is it an accurate
sampling of today's application domains?

------
nrubin
This has to be one of the clearest academic papers I have ever read. Aside
from the content, the author does a really good job explaining his thesis. I
wish more academic papers were written this way.

~~~
kaeluka
I wish that none were written this way: Using a sample size of 4, the paper
proposes some layer model. Already the first language (erlang) does not
correspond to this model, yet the model will later be concluded to be the way
to go: "A surprising result is that the four resultinglanguages have a common
structure (comment: no, they don't). [...] I postulate that this common
structure will be part of one possible deﬁnitive programming language".

Then we have four conclusions:

1\. the notion of declarative programming is a the 'core' of programming
languages

2\. it will also stay there

3\. it is concluded that message passing " _seems_ to be the correct default
for general purpose concurrent programming" (my emphasis)

@1: what's the 'core'? Without any useful definition, this is a meaningless
statement.

@2: aha! The core seems to change over time. OK, I rephrase my last question:
what's the 'core' today?

@3: First, it's a weak conclusion that something 'seems' to be the case. But,
ignoring the odd usage of the word 'correct', how does the author support this
conclusion? It seems like the author thinks that presenting a couple examples
_for_ your proposed solution (message passing) allows to conclude that a
competing solution (shared memory programming) is worse. I fail to see
evidence for that. Yeah, programming with locks is harder than programming
with actors. But it's also more expressive, so the comparison is unfair. If
you want to compare erlang to, say, java, you need to compare it to
programming with higher level data structures (queues, actors, ...).

btw, this one's a gem: "Declarative concurrency is a deterministic form of
concurrency that is much simpler to program with than the shared-state
concurrency used in mainstream languages such as Java [18]" \-- if you look at
[18], it doesn't support the simplicity claim; it's a reference to Doug Lea's
"Concurrent Programming in Java". The simplicity claim remains a claim. That
may be sloppy writing. Or not.

~~~
seanmcdirmid
I believe this was an invited talk at FLOPS, so the standards and expectations
of rigor are a bit different.

------
rouanza
Its behind some signup wall. Post a direct link.

~~~
zik
Sorry, I don't get a signup wall.

Here's a link to the author's slide set from FLOPS 2006 if the above doesn't
work:

[http://www.info.ucl.ac.be/~pvr/flopsPVRtalk.pdf](http://www.info.ucl.ac.be/~pvr/flopsPVRtalk.pdf)

