I love watching Joe Armstrong speak, he's so dynamic, fun, and energetic. This was my first opportunity to see Jones. Listening to the two of them together was great fun to hear their discussion.
The InfoQ interviewer was terrible though :P. He puts the breaks on a good discussions multiple times. The interviewer doesn't ask very many good questions from the context of Erlang or Haskell.
This makes me realize I would listen to a podcast of them debating and discussing stuff. And I never listen to any podcast.
They're both pretty nice guys, always civil in their opinions (a bit less for Joe Armstrong when he talks about OOP). Their talks are pretty much always interesting, and they both have a tendency to use Comic Sans MS in their slides.
I am the interviewer, and I find it is kind of sad to have this aggresively negative reactions after all the work done for having this result that seem to be interesting for a lot of people. Maybe some questions do not interest you, but I have a wide variety of audience that I need to satisfy. Can you please precise what questions you felt irrelevant?
I appreciate the interview you did. I found it enlightening, and watching and listening the whole clip increased my knowledge and understanding on programming in general, as well as on functional languages and the background of Erlang and Haskell.
The second question ("Haskell and Erlang have 2 distinct models of concurrency, right? Haskell is going to side-effect free, Erlang is about messaging. Can you talk a bit about this in contrast to both models of concurrency?") was especially interesting to me. I'm not experienced with functional programming, and I'm interested in the unique characteristics of Haskell and Erlang. This question directed Armstrong's and Jones' discussion towards the differences in the languages, even though they did not clearly answer to the question.
For the sake of feedback, the question starting with "Yes. This is in sync with how things happen, but sometimes it gets out of sync. It's the same thing with when you are dealing with processors"(...) was a bit hard to grasp. The mental models related each programming languages are interesting, but your question directed the discussion away from the issue of mental models. Perhaps asking "what do you see as the mental models of Haskell and Erlang" would have done the job?
Anyway, thanks for the interview, it was beneficial to me, and I'm surely not the only one.
@jollojou
I agree my question was confusing, maybe due to the fact that we had an offline discussion before about that so that I didn't communicate all the information. Thank you for your feedback, and I am glad you appreciate the interview.
@sadache I can appreciate how you feel. I've certainly posted hard work on HN plenty of times only to be criticized.
Regarding my reaction, it certainly wasn't meant aggressive, but it was a negative review. I appreciate you getting these two together for an interview, and their disucssion was awesome. So thank you for that, but as I said previously... your questions seemed to interrupt a good flow of conversation that Armstrong and Jones had for the sake of asking a question.
You asked several questions, asserting them in the context of scala. It would have been my personal preference to have JA and SPJ talk about the two languages (Erlang/Haskell) in relation of each other. A compare/contrast, pros/cons, from their perspectives.
Finally, these series of questions below, didn't yield information specific to the languages and the setup of the questions left me confused.
That takes us to a discussion about user's model. For me, as a user of Haskell, I have a mental model that everything is happening by the end. That's what the type system tells me - that everything is saved until the end.
Yes. This is in sync with how things happen, but sometimes it gets out of sync. It's the same thing with when you are dealing with processors. You are sending messages, but sometimes it's maybe not that cheap to send a message and also it hits barriers of using this mental model that you established. What do you think of this problem?
With any feature of the language, you define a mental model for the programmer, so that the programmer can reason about this feature. The implementation tries to get in sync with this mental model, but it's not always true. In some cases, it gets far from it. It's the same thing with processors, when you are sending messages. It's not exactly the same thing, because you need to copy or you don't need to copy. Sometimes it's not performant to do it that way, you do it another way. What do you think of this problem? The same thing with I/O, that as a programmer I think that is happening by the end, but it is actually happening on the fly, it's happening right away.
With all that said, I'm an avid infoq website fan and I do appreciate you getting this interview and your work. I apologize for coming across aggressive, as I certainly didn't mean too. (hence the :P)
@roder as I stated earlier, I have a wide variety of audience, mainly enterprise devs that are interested also in Scala (which inspires a lot of its feature from both of the language). I guess Joe's statement about having interoperability breaks boundaries (see http://sadekdrobi.com/2009/09/27/a-piece-of-wisdom-by-joe-ar... ) is very important for decision of choice of programming languages. Also the fact that Scala is not a full Actor Model is interesting for audience of InfoQ. The User's Model is very important regarding programming language design since once you get to performance issues you need to look beyond this model to actual implenmentation (I guess you are aware of tutorials that oversemplify concepts like Monads and Lazyness to mention few).
I am glad you found an interest in the interview, and thank you for your constructive critics.
It's easier in a book type setting, no? I mean you get to sit around and think of questions, and you have just one guy, rather than two geniuses sat there right in front of you.
Indeed. (I deleted my reply because I had more to add to mononcqc's, but you were awfully quick on the draw!)
Also, I thought the _Coders at Work_ interviews were quite good (I've read about half, so far), but found the _Masterminds of Programming_ disappointing (except the one with Chuck Moore).
Great interview with two of the smartest guys in the business. If you're interested in the history of these two languages, and what they're good at, this is a fascinating read. I'd like to watch the video of it, but I don't have time (to make it clear: I read it - click on 'expand all').
I thought about just reading it, but after having it play for about 5 minutes I realized I really wanted to watch them say it. They're both very dynamic and you get a lot more of the nuance from their body language and inflection.
Also, the transcript has a few errors. They are generally fairly benign, but it was a bit confusing to read "pool" for "pull" and a few of the quotes and apostrophes weren't in the right places.
It's great to hear these two talk informally about their respective projects. As well as hearing about the similarities and differences between Erlang and Haskell, it's nice to get a little insight into how their creators think and approach the same problems.
The site is so awful that I clicked "show all" and copy-pasted the entire thing into a text file. It must've taken them special effort to make transcript reading suck so badly.
I do the same thing on that site all the time: copy all text and read it in the text editor.
I hope that someone from InfoQ is reading HN - can you please rethink the design of the site? You have great content, but usability could use some serious improvement...
I'd love to make the transcripts more useable so please do let me know how would you imagine a better solution. Initially we've thought that synchronizing the transcript with the interview and allowing to jump to specific questions is quite innovative, but I'd definitely love to hear more ideas.
And just to avoid 'spamming' HN, you can always drop me an email: alex at infoq.
Hi Alex, great to see that you guys read HN. You're doing a good job with the content. That said, here's some suggestions in an irreverent tone:
1) The transcript shouldn't be a scrollable window. Scrollable windows within scrollable windows suck, especially when people use the mousewheel.
2) The transcript should take up a lot more than freaking 13% of the screen. (Just measured that in Photoshop, browser maximized, 1280x1024) It's the main content that most people come to see.
3) The "expand" buttons should not exist. Everything should be expanded, always. Ever try to read a blog post by clicking to expand each paragraph?
Those are the big issues. Try to emulate the Google Docs reading experience (see semmons's link higher up the thread). If you want little buttons next to each paragraph that skip to that place in the video, fine. I don't object to those.
I agree that this is an interesting talk, with more common ground than I expected. Here's a bit that struck me as a Lisp guy (this is Armstrong talking):
In a module you can say there's a parse transform, and the parse transform is given the parse tree of the program and it can turn it into another parse tree before it's given to the compiler.
Sounds like a Lisp macro, doesn't it? Except he then has to go into detail about how the parse trees are represented.
The end result is relatively similar. Erlang has an underlying representation that uses something akin to prefix notation, albeit more verbose and a lot uglier than what you'd get from lisp. Here's a blog post with an Erlang Abstract Syntax Tree described in it: http://seancribbs.com/tech/2009/06/20/building-a-parser-gene...
In essence, this can get close to lisp macros; with parse-transforms, some people have developed modules as objects, qlc (querying an mnesia database as a list comprehension), cancelling out single assignment, etc.
The ways to do this are rather obscure and not too documented. I think that it's a bit fortunate (arguably) because it makes it harder for people to build illegible macro systems.
I've written before that if you represented an AST as a data structure, wrote a function to transform one instance of that structure into another, and ran it at compile time, you'd have something close to Lisp macros. What's interesting about this Erlang example is that people are actually doing it. My suspicion is that it's more trouble than it's worth. The simplicity of the sexp representation and the fact that it's the same representation as the original language (no special notation for ASTs) are what make macros so natural in Lisp. Take away those properties and things will get messy quickly. But it might still be worth it for writing certain kinds of tools.
If you want to write lisp macros in Erlang, Robert Virding's Lisp Flavored Erlang might be what you look for: it's a lisp syntax on top of the Erlang VM (so it should be compatible with everything else) and it's supposed to support more powerful macros (http://github.com/rvirding/lfe).
The InfoQ interviewer was terrible though :P. He puts the breaks on a good discussions multiple times. The interviewer doesn't ask very many good questions from the context of Erlang or Haskell.