
Interviews with programming language creators (2010) [pdf] - MrXOR
http://www.math.bas.bg/bantchev/misc/az.pdf
======
open-source-ux
Here's a quote from the Ada interview with S. Tucker Taft

> _Do you have any advice for up-and-coming programmers?_

> Learn several different programming languages, and actually try to use them
> before developing a religious affection or distaste for them.

> Try Scheme, try Haskell, try Ada, try Icon, try Ruby, try CAML, try Python,
> try Prolog. Don’t let yourself fall into a rut of using just one language,
> thinking that it defines what programming means.

> Try to rise above the syntax and semantics of a single language to think
> about algorithms and data structures in the abstract. And while you are at
> it, read articles or books by some of the language design pioneers, like
> Hoare, Dijkstra, Wirth, Gries, Dahl, Brinch Hansen, Steele, Milner, and
> Meyer.

I think this point...

 _Try to rise above the syntax and semantics of a single language to think
about algorithms and data structures in the abstract._

...is a stage that not many programmers reach (I certainly haven't). Agree or
disagree? Or do you think it's importance is overstated?

~~~
chubot
I will be immodest and say that I reached that stage a long time ago. Because,
for better or worse, I learned CS before I really learned to program :-/ I did
program in middle/high school, but not very often, and I was bad it. I was
better at reasoning about data structures than debugging, and I think the
latter skill is "table stakes" before calling yourself a programmer.

As a concrete example of thinking outside a particular language, My shell Oil
is 24K lines of code that does most of what bash does at 140K LOC, written
_not_ in Python, but:

1\. OPy, a subset of Python 2 --
[http://www.oilshell.org/blog/2018/03/04.html#faq](http://www.oilshell.org/blog/2018/03/04.html#faq)

2\. Zephyr ASDL -- [http://www.oilshell.org/cross-ref.html?tag=zephyr-
asdl#zephy...](http://www.oilshell.org/cross-ref.html?tag=zephyr-asdl#zephyr-
asdl)

3\. a mathematical dialect of regular expressions (that runs under both
Python's re engine and re2c's dialect, via translation).

In other words, it's a composition of DSLs, independent of any language.

I started a translator from OPy (typed with MyPy) to C++. It partially works
but doesn't translate the whole codebase yet. If it works then I will have
fully achieved this "language abstraction" goal.

It's analogous to how TeX was implemented by Knuth. TeX is not implemented in
Pascal and compiled with a Pascal compiler. It's implemented in H-Pascal, and
abstract subset of Pascal. Then it's _translated_ to C and compiled with a C
compiler!

[https://news.ycombinator.com/item?id=16526151](https://news.ycombinator.com/item?id=16526151)

In case it isn't obvious, this makes the style of code VERY different and more
abstract than what you see in every other codebase.

This approach has downsides -- namely that the shell is way too slow right
now. Hopefully the translation will fix that. Either way, I can definitely
claim that the ideas and architecture are completely separate from any
programming language. I've documented a lot of these ideas on the blog:

[http://www.oilshell.org/blog/](http://www.oilshell.org/blog/)

~~~
smcl
Have you got an article where you talk a bit about point #3 - "a mathematical
dialect of regular expressions". The words all make sense, but I cannot
picture it :-). Your Oil posts always appear up on lobste.rs shortly after
they're posted and I thoroughly enjoy them, but I must have missed a few!

~~~
carapace
I don't know if this is relevant to what Chubot's doing but Brzozowski’s
Derivatives of Regular Expressions are pretty mathy. (Disclosure, I wrote
this)
[http://joypy.osdn.io/notebooks/Derivatives_of_Regular_Expres...](http://joypy.osdn.io/notebooks/Derivatives_of_Regular_Expressions.html)

~~~
chubot
That's cool -- I have a big page of notes on derivatives and have thought
about replacing my usage of re2c with them (re2c being automata-based).

One benefit of that is aesthetic -- re2c is a 30K line piece of C code itself.
The other benefit is practical -- it would be nice to "hoist" it up to the Oil
language level, so shell users can use efficiently compiled regexes.

And I filed this issue to try derivatives awhile ago:

[https://github.com/oilshell/oil/issues/197](https://github.com/oilshell/oil/issues/197)

There is a possible performance win, but I'm not sure if it makes sense. If
you see anything interesting there I'd love to chat about it! (contact info in
profile)

\-----

What I mean by "math" is either automata-based methods or derivatives. In
contrast, Perl-style backtracking engines aren't math.

To me, the "magic" of "regular languages" is that they give you non-
determinism for free. The equivalence between NFAs and DFAs isn't obvious, and
it's useful in practice.

I've taken advantage of this free nondeterminism in my huge shell lexer. (See
my other reply for details)

~~~
carapace
I'm enamored of dRE (as I call it) but pragmatically it seems to me you could
stick with re2c.

I think it's interesting to generalize dRE to general control-flow (not just
parsing.)

Are you aware of Abstract State Machines?
[https://en.wikipedia.org/wiki/Abstract_state_machine](https://en.wikipedia.org/wiki/Abstract_state_machine)

------
AnimalMuppet
"Start with a brand new language and you essentially start with minus 1,000
points. And now, you’ve got to win back your 1,000 points before we’re even
talking. Lots of languages never get to more than minus 500. Yeah, they add
value but they didn’t add enough value over what was there before." \- Anders
Hejlsberg

I think this is very insightful. It's not enough to add (some) value. A
language has to add enough value to matter to enough people in enough
situations, or it doesn't gain any traction.

~~~
breck
That’s a great quote. Also explains why we are seeing less new languages per
developer capita nowadays, but far more packages. (There are about 10k
languages, over 2M packages)

------
Jorge1o1
Mindblowing quote from Anders Hejlsberg: “You can sort of view the sharp sign
as four pluses, so it’s C++++” [1]

Never thought about it that way.

[1]
[https://www.computerworld.com.au/article/261958/a-z_programm...](https://www.computerworld.com.au/article/261958/a-z_programming_languages_c_/?pp=2)

~~~
layer8
I always thought of it as (only) two pluses, just differently arranged
(diagonally overlapped).

~~~
DonaldPShimoda
Yeah but I think the idea is that it's (C++)++, i.e., the version that comes
after C++ (which is the version that comes after C).

~~~
arithma
Which does not compile in C++ or C# :)

~~~
saagarjha
Only because postincrement returns an rvalue. (++C)++ would be valid :)

------
tosh
Impressive to see how the design decisions of Clojure hold up so well 10 years
later.

Also couldn't help but smirk when I read the answer to "What do you think will
be Clojure’s lasting legacy?":

> I have no idea. It would be nice if Clojure played a role in popularising a
> functional style of programming.

------
taspeotis
Stroustrup C++ 'interview' [1]

[1] [https://www-users.cs.york.ac.uk/susan/joke/cpp.htm](https://www-
users.cs.york.ac.uk/susan/joke/cpp.htm)

------
divs1210
I loved reading Coders at work[0], it had a wealth of insight. This looks
similar and interesting!

[0]
[https://en.wikipedia.org/wiki/Coders_at_work](https://en.wikipedia.org/wiki/Coders_at_work)

------
AnimalMuppet
Huh. Guido van Rossum's title was originally "First Interim Benevolent
Dictator For Life".

------
pwm
Nice, this looks pretty similar to Coders at Work + they both came out around
the same time. Anyone knows if they share a common origin?

------
abvr
I'm a bit disappointed that there's no DMR here, but seems to be a pretty
interesting document otherwise.

------
razza357
Where is the interview with the author of Brainfuck??

~~~
dentemple
Our minds would not be able to comprehend the answers.

~~~
merlincorey
I know you are joking, but as an esoteric programming language nerd...

Actually, brainfuck is pretty straightforward and is basically a very low
level language for dealing with turing tape machines using only 8 primitives.

It's definitely not very human readable, but then, neither is actual machine
code -- we use assembly mnemonics to be able to read and understand it.

------
suyash
The most important language is missing :P Java

~~~
kazinator
C is also not there, nor any Lisp.

Detailed historic material about these is copious.

It's interesting to see interviews like with Luca Cardilli of Modula-3 and
such.

~~~
merlincorey
> C is also not there, nor any Lisp

Shots fired at Rich Hickey and Clojure, then, as they are in the PDF.

------
bluenose69
The TOC lists C# and C++, but no C.

~~~
augustk
And Modula-3 but not Modula-2, Pascal or Oberon.

~~~
kazinator
Well, those three would be one interview with the same person. The problem
here is getting a interview, not just gathering historic material. Anyway,
there is no shortage of detailed historic knowledge about the Wirth languages.

------
lelf
(2008–2010).

