[{"_1":2,"_84":-5,"_85":-5},"loaderData",{"_3":4,"_35":-5,"_36":37,"_70":71,"_82":-5,"_83":-5},"root",{"_5":-5,"_6":-5,"_7":8,"_20":-5,"_21":22,"_23":24,"_27":28,"_33":34},"user","shoppingCartId","shoppingCart",{"_9":10,"_11":12,"_13":14,"_15":16,"_17":18,"_19":12},"count",0,"free",true,"updatedAt","2026-01-23T03:56:05.384Z","paymentGateway","STRIPE","cartItems",[],"loading","toast","locale","en","constants",{"_25":26},"paypalClientId","AX53Cwz8jR6rVVzzZiZNWWXl0dGagi-GZrjG-S3Ua14E5nrKMn7DxDQ730O4R8LusLPp49ALn6aRVaEy","publishers",{"_29":30,"_31":32},"companies",[],"universities",[],"needsLocaleCookieSync",false,"routes/_store+/_readers+/read_/route","routes/_store+/_readers+/read_.$slug/route",{"_38":39,"_64":65,"_66":67,"_68":34,"_69":-7},"book",{"_40":41,"_42":43,"_44":-5,"_45":46,"_49":50,"_52":53,"_62":63},"title","Lisp Hackers","slug","lisphackers","metaText","coverFeatured",{"_47":48},"url","https://d2sofvawe08yqg.cloudfront.net/lisphackers/s_featured?1620382904&1620382904","coverFeatured2x",{"_47":51},"https://d2sofvawe08yqg.cloudfront.net/lisphackers/s_featured2x?1620382904&1620382904","authors",[54],{"_55":56,"_57":58,"_5":59},"id","Z2lkOi8vbGVhbnB1Yi9TdG9yZTo6UHJvZHVjdEF1dGhvci82MDc1","name","Vsevolod Domkin",{"_60":61},"username","vseloved","showReadLinkString","full","parts",[],"toc",[],"isUnavailableOnline","unavailableMessage","routes/_store+/_readers+/read_.$slug.$chapterId/route",{"_40":41,"_72":-5,"_38":73,"_79":-5,"_80":81},"content",{"_74":75,"_40":41,"_44":-5,"_42":43,"_62":63,"_76":77,"_78":-5},"previewContent","

A Short Intro

\n\n

The idea of this series came to my mind after\nEuropean Common Lisp Meeting 2011 where\nI had had a chance to meet in person some of those mythical 100x more\nproductive programmers. And the points I wanted to make were:

\n\n

these guys do exist, and it’s really interesting to know how they\nwork and think
it makes sense to show who are the real people using this obscure\nand mythical language Common Lisp, why do they use it and what they\ndo with it

This book is a collection of short interviews with 14 prominent\nindividuals from different parts of the world, from Australia to\nCanada, and of different occupations, from low-level programmers to\nphysicists and musicians, asking them a more-or-less similar set of\nquestions on the following topics:

\n\n

their general attitude to programming
attitude towards and experience with Lisp
stories of real-world Lisp projects

Overall, this should give an insight into why people use Lisp, as well\nas help the readers gain some new experience and improve as programmers.

\n\n

How were these individuals chosen? I looked for people who possess at\nleast 2 of the following 3 essential qualities:

\n\n

a renown Lisp open-source contribution
prominence in the community
experience working for successful Lisp companies
… and a good perspective on other languages was considered as a\npleasant bonus

Definitely, not all of the hackers I’d like to interview are here.\nFor various reasons. There are lots more interesting Lisp people with\nfascinating experiences worth sharing, and, hopefully, this will happen\nin the future in one form or the other. Yet, here are these 14 unique\nlispers with their stories, world views and insights. Enjoy!

\n\n

P.S. As a bonus you’ll find some interesting bits of history of SBCL\nand Slime, the two most important open-source Common Lisp tools,\ntold by their main developers.

\n\n

A Few Quotes

\n\n

\n
I’ve been using CL exclusively for the last six or\n seven years. As I was working freelance, this was kind of easy —\n I either had projects where the customer didn’t care about the\n programming language that I used as long as I got the job done, or I\n was hired specifically for my CL skills.
\n\n
– Edi Weitz
\n

\n\n

\n
I love hanging out with Lisp hackers: I find that we’re an unusually\n diverse community. How often do you attend a small conference where\n attendees are building nuclear defense systems, running intensive\n care wards, designing aeroplane engines, analysing Lute tablature,\n developing cancer drugs, writing FIFA’s legal contracts, and\n designing their own microchips?
\n\n
– Luke Gorrie
\n

\n\n

\n
When what I have to do is solve problems that no language has\n built-in libraries for, then I want to be working in a language\n where I can focus on the problem itself, rather than the detail of\n that language — and for me, Lisp permits that kind of separation of\n concerns, given its easy support for DSL and embedded language\n generation, protocols, and the ability to run partial programs.
\n\n
– Christophe Rhodes
\n

\n\n

\n
In one of our research topics we had to solve huge instances of\n 3-SAT problems using a very basic algorithm. The fact that Common\n Lisp comes with bignums reduced the development time to one\n afternoon and the program we produced was faster than the C++\n prototypes we had.
\n\n
– Juan José García Ripoll
\n

\n\n

\n
In the end, Lisp won me over because it turns out that it is the\n mother of all languages. You can bend it and turn it into whatever\n language you want, from the most flexible and reflective interpreted\n scripting language to the most efficient and static compiled\n production system.
\n\n
– Pascal Costanza
\n

\n\n

\n
For typical projects I feel like I’m building more tools into my\n REPL workbench. I don’t write scripts that I call from the command\n line, I write functions that I call from the REPL, and use the slime\n and Emacs environment to create and interact with data, whether it’s\n data from a file, from a computation, from the web, a database, etc.
\n\n
– Zach Beane
\n

\n\n

\n
It’s also very easy to turn Common Lisp REPL code into unit tests,\n which I tend to do a lot. That is something that’s very hard to do\n with object-oriented code, which is why idiotic things like\n dependency injection and Test-Driven Development have to be\n invented.
\n\n
– Vladimir Sedach
\n

\n\n

\n
There’s a clear difference between the Lisp workflow where you\n change the state of your image interactively to get the code into\n working shape very quickly (and then later try to remember what it\n was you did) and the more scripted approach of test-driven\n development in Ruby where you put everything (code, test setup,\n assertions) in files that you reload from disk on each run.
\n\n
– Daniel Barlow
\n

\n\n

\n
When I’m trying to understand someone else’s code I tend to find the\n best way is to refactor or even rewrite it. I start by just\n formatting it to be the way I like. Then I start changing names that\n seem unclear or poorly chosen. And then I start mucking with the\n structure.
\n\n
– Peter Seibel
\n

\n\n

\n
The greatest thing about Common Lisp is that the standardization\n process drew from years and years of experience and organic\n growth. This makes the language feel singularly solid and\n practical. Most languages feel immature compared to CL.
\n\n
– Marijn Haverbeke
\n

\n\n

\n
We don’t use Lisp, but much of our software is built on ideas\n borrowed from Lisp. We don’t use it because we needed low level\n control — most of the code is written in C++, even with some bits of\n assembly. But we’ve borrowed an enormous number of ideas from\n Lisp. In fact, if we weren’t Lispers, we would have built a very\n different (and I think significantly more inferior) product.
\n\n
– Slava Akhmechet
\n

\n\n

\n
On the upside, we certainly have been able to write quite advanced\n software that we might not have otherwise managed. A million lines\n of Lisp code, including its fair share of macros and DSLs, would be\n so many more million lines of code without the syntactic abstraction\n made possible by Lisp. However hard and expensive it was with Lisp,\n I can only imagine how many times worse it would have been with\n anything else.
\n\n
– Faré Rideau
\n

\n\n

\n
I think we would all be better off if we hadn’t balkanised the\n different systems that we program for — and Lisp is one of the few\n programming languages with the flexibility to serve in all these\n roles.
\n\n
– John Fremlin
\n

\n\n

\n
The language itself is somewhat good enough and anyway Common Lisp\n makes it really easy to change most of itself to add the new and\n cool stuff or ideas of the day.
\n\n
– Marc Battyani
\n

\n\n

Zach Beane (USA)

\n\n

Zach Beane is the uniting link of the whole community. The creator of\nQuicklisp and a number of useful\nopen-source libraries, like Vecto\nand ZS3, he is also always active on\n#lisp irc channel answering questions, as well as keeping\na blog, where he shares interesting\nLisp news, and supporting Planet Lisp blog\naggregator. And that’s not all…

\n\n

His twitter is @xach

\n\n

Tell us something interesting about yourself.

\n\n

\n
I live in Maine and enjoy hacking Common Lisp projects for fun and profit.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I work at a small telephone and Internet company.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
I currently use Lisp to analyze some large data files we get from\n vendors and partners and produce reports. I’ve recently used Lisp to\n produce KML files for Google Earth visualization of some internal\n data. I use stuff like cl-ppcre,\n drakma,\n postmodern,\n cl-mssql,\n cxml, and more to gather data\n from various systems when preparing reports. The growing library\n ecosystem has made it really easy to get stuff done.
\n\n
Lisp is accepted because I can produce useful stuff pretty quickly\n with it. It’s a small company with a small team so there isn’t a\n bureaucracy to fight to use something non-standard. Does the tool\n work? Is the result useful? Then there’s no problem.
\n\n
In some cases, where it isn’t a good fit for the final product, I\n use Lisp to prototype ideas before writing a final thing in some\n other language, e.g. C or Perl. But I even use CL to generate data\n and code in other languages, so it’s still in the mix, still a part\n of my workflow.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
Paul Graham’s “Beating the Averages”\n describes a really exciting way to use an uncommon tool to great\n advantage. That got me interested in how I could do the same\n thing. I started off with some stuff in Scheme because I thought CL\n was old and crufty and gross, but when I started using SBCL I found\n it was a great, practical tool, and I never stopped using CL after\n that.
\n\n
I continue to use CL because it has a great mix of features (object\n system, first-class functions, fast compiled code, multiple\n implementations, a fantastic standard, etc, etc) and it works well\n in my favorite working environment, Emacs on Linux. I feel like I\n know it well and I can see quickly how to use it to explore and\n solve new problems.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
Making graphics with Lisp for\n wigflip.com. It’s always fun to have an idea\n about some kind of visual toy and then tinker with it until it’s\n right.
\n\n
It’s also fun to do something fast. A few years ago I got a project\n to fill out some PDF forms automatically. The project started with a\n few days scheduled to research third-party solutions, but in those\n few days I had a working prototype that used\n CL-PDF and\n CLSQL.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
There are a lot of negative perceptions about Common Lisp that are\n reinforced by current and former Common Lisp users. I can accept\n that CL is not for everyone, but some of the criticism is just years\n (sometimes decades) of moaning and nitpicking about decisions made\n in the distant past that are not really up for review right now. I\n wish the people who are vocally, chronically dissatisfied with CL\n would go off and do their own thing and stop bothering people that\n are happy with Common Lisp.
\n\n
There are some remarkable trolls that like to pick on CL, but\n they’re not usually taken seriously by anyone, but “insiders” who\n complain about CL are perceived to be giving some sort of genuine\n insight. It’s very annoying.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
Quicklisp has been very rewarding. There’s a lot of positive\n feedback from people who feel it really helped them use CL more\n easily. More generally, the whole CL ecosystem has been a lot of\n fun. I enjoy trying new libraries, sending feedback and bug reports,\n helping people get started, and all that stuff. Common Lisp has a\n lot of smart, helpful, friendly people who share a lot of knowledge,\n and I feel lucky to get to learn from them and to try to share what\n I know, too.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
For typical projects I feel like I’m building more tools into my\n REPL workbench. I don’t write scripts that I call from the command\n line, I write functions that I call from the REPL, and use the slime\n and Emacs environment to create and interact with data, whether it’s\n data from a file, from a computation, from the web, a database, etc.
\n\n
I find it really helps to have small, focused functions that are\n easy to follow and that do one thing and do it well. The fine\n granularity of testing, tracing, intermediate values, etc. can help\n wire together a very useful set of behaviors from a small core of\n simple functions.
\n\n
Some productivity ideas…
\n\n
Knock the rough edges off your working environment. Write code to\n automate stuff. Make it easy to repetitively do complicated but\n boring stuff. For example, I used to be afraid of the hassle of\n making new releases of my projects, but recently wrote a CL program\n that does everything for me, from PGP-signing the tarballs to\n uploading them along with the documentation to my website. Now I\n don’t care if I make ten project releases in a day, it’s just a few\n function calls.
\n\n
Customize your environment to make it comfortable. Make it easy to\n look up info in the hyperspec or in other documentation\n sources. Make it easy to create new projects. I use\n quickproject a lot for\n that, but I also have some Emacs templates that put some boilerplate\n into my files automatically. Make a program do your work for you.
\n

\n\n

How did quicklisp change your life? What are current plans for its development?

\n\n

\n
I can get up and running in a new environment very quickly\n now. Before Quicklisp, I could usually build up a set of libraries\n that were comfortable and useful, but it could be a hassle to move\n them from computer to computer, or to make sure they were\n up-to-date. Now I just use Quicklisp and don’t worry about it.
\n\n
As Quicklisp maintainer, it’s really helped me see where some people\n are coming from when they want to try Common Lisp. It’s a totally\n different mindset than what I’m used to. I think there’s room for\n some documentation or tutorial on the system-oriented,\n REPL-workbench style of Common Lisp development that I like to use.
\n\n
I want to write more documentation for Quicklisp, particularly how\n users can publish their own software for it or customize it via its\n internal protocols.
\n\n
I also want to gather and share documentation for all\n Quicklisp-loadable projects, so there can be a single place to learn\n what a given project does, and get access to all its documentation.
\n\n
I’d also like to make it easy for people to share feedback about\n their experiences with a project, so you could decide if it’s likely\n to fit your needs. Something like the feedback you see for products\n on Amazon, but for Lisp libraries.
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
As a fantasy project, I’d love to make a system for interesting\n visualization of complex data, something where it’s easy to splat\n something quick and dirty on the screen/page, but which can grow in\n capability as the need arises. Or maybe just some tool for making\n audiovisual toys, with cool pictures and noises coming out.
\n

\n\n

Anything else I forgot to ask?

\n\n

\n
Common Lisp is a great system that rewards in-depth study.
\n

\n\n

\n $\"xach\"$

xach

\n\n

2012-03-10

\n\n

Edi Weitz (Germany)

\n\n

Edi Weitz doesn’t need to be introduced in the Lisp community.\nHis vast contributions to open source Lisp, made during the last decade,\ncollectively known as Ediware, include the indispensable regex library\nCL-PPCRE, written on a bet in Hamburg café,\nand a whole stack of web-related libraries with the most widely\nused Lisp application server\nHunchentoot and HTTP client\nDrakma. Together with\nArthur Lemmens he co-organizes\nEuropean Common Lisp Meeting.

\n\n

Tell us something interesting about yourself.

\n\n

\n
Well, I’ll leave it to someone else to tell you what’s interesting\n about me. I’ll rather tell you what I find interesting in addition\n to Common Lisp: I collect photo books and I’m doing a bit of\n photography myself. I\n like to listen to the music of Frank Zappa and to Jazz. I read a\n lot. I’m interested in mathematics, especially in\n set theory.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I’m a professor for mathematics and computer science at the\n University of Applied Sciences in\n Hamburg. I started this job in September 2011.
\n\n
Before that, I was a freelance hacker for about 13 years.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
In my new job, I’ve been using CL in my math lectures a couple of\n times and will continue to do so.
\n\n
In my old job, I’ve been using CL exclusively for the last six or\n seven years. As I was working freelance, this was kind of easy —\n I either had projects where the customer didn’t care about the\n programming language that I used as long as I got the job done, or I\n was hired specifically for my CL skills.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
I came to Lisp via Emacs Lisp in 1999 or so. What got me hooked was\n the wonderful book\n “Writing GNU Emacs Extensions”\n by Bob Glickstein. It opened my mind for the beauty of the Lisp\n language family — something I had missed the first time I had\n encountered Lisp (in university, a few years earlier). The two CL\n books by Paul Graham and Norvig’s\n PAIP then paved the way for Common\n Lisp.
\n\n
What holds me is that I haven’t found a better programming language\n so far — and I don’t expect to find one very soon.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
I don’t know if “exciting” is the right word, but it makes me happy\n that so many people use\n “The Regex Coach” and like it. I\n stopped keeping track, but there must have been at least half a\n million downloads since 2003.
\n\n
I’m also kind of proud that some of my open source libraries are\n used by various commercial and research projects around the world.
\n\n
But probably the most awe-inspiring encounters I had with Lisp were\n the few occasions when I played around with Genera or watched\n someone else using it. I think this OS really was a work of art.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
There’s nothing I really dislike about Common Lisp. There are a few\n warts here and there, but so far I’ve found nothing that was serious\n enough to prevent me from being productive.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
Working on the Windows port of Piano — an\n extremely impressive application which has been around for almost 20\n years and has been used by almost every aircraft manufacturer in the\n world. Dimitri Simos, Piano’s main author, has been the most\n enjoyable client I’ve worked with so far.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
I usually just start up the LispWorks IDE and hack away. The best\n productivity tip I can give is to stick with one implementation and\n IDE and to invest a lot of time to really learn how to use it —\n including all the implementation-specific goodies like debuggers,\n inspectors, steppers, browsers, and so on.
\n

\n\n

Ediware became hugely popular (by Lisp standards), and with this popularity came a lot of work and responsibility. You seem to have mostly handed over supporting it to Hans Hübner. What’s up next for you in the land of programming and Lisp in particular?

\n\n

\n
I’m planning to give a lecture about the use of AI techniques in\n games in the next year and I might use some Lisp there. I might also\n — as a sideline — resume my CL consulting work sooner or later. I\n don’t expect to publish new open source code in the near future,\n though.
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
When I was still working as a hacker, I always dreamt of finding\n someone to pay me for working on an open-source CLOS object store —\n written in pure Common Lisp, OS-independent, portable, not relying\n on third-party software, fast, reliable, thread-safe,\n well-documented, etc.
\n

\n\n

\n $\"edi\"$

edi

\n\n

2012-03-14

\n\n

Slava Akhmechet (USA)

\n\n

Slava Akhmechet published several enlightening essays at his website\ndefmacro.org, of which one I often recommend to\npeople, interested in learning about Lisp:\nThe Nature of Lisp. He\nalso created a continuation-based Lisp web-framework —\nWeblocks, backed by a\ndelimited continuations library\ncl-cont. Other then that he\nis a co-founder of a startup company RethinkDB, of which he tells a\nbit in the interview.

\n\n

Tell us something interesting about yourself.

\n\n

\n
For a long time I thought that human achievement is all about\n science and technology. In the past few years I realized how misled\n I was. Hamlet is as important an achievement as discovering\n penicillin. I wish I’d figured out earlier that science, for all its\n usefulness, is very limiting if one adopts it as an article of\n faith.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I’m a founder at RethinkDB. We spent\n three years building a distributed database system that we’re about\n to open source and release in the next two weeks. The system allows\n people to easily create clusters of machines, partition data in a\n click of a button, and run advanced, massively parallelized,\n distributed queries using a very comfortable query language we’ve\n designed. The product is really delightful to use — we were just\n playing with it today to analyze census data for the upcoming\n presidential election in the U.S. and using it to play with the data\n is a real joy. I’m very proud of what we’ve done here — I hope it\n will make lots of people’s jobs easier and let them do things they\n couldn’t have done before.
\n\n
My job here is to do the most important thing at any given\n time. Sometimes it means fixing bugs, sometimes it means demoing the\n product to customers, and sometimes it means driving to buy supplies\n so our developers can get their jobs done.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
We don’t use Lisp, but much of our software is built on ideas\n borrowed from Lisp. We don’t use it because we needed low level\n control — most of the code is written in C++, even with some bits of\n assembly. But we’ve borrowed an enormous number of ideas from\n Lisp. In fact, if we weren’t Lispers, we would have built a very\n different (and I think significantly more inferior) product.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
A guy named bishop_pass on gamedev.net forums about fifteen years\n ago. He was a really good advocate and I respected his opinions\n because of other subjects, so I decided to check Lisp out. I enjoyed\n it immensely, and spent years hacking in it. Today the only Lisp I\n still use is Emacs Lisp. I honestly don’t know if I’ll program in\n Lisp again (other than for fun, of course), but the ideas behind it\n will be with me forever.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
I built cl-cont — a macro that converts Lisp code to continuation\n passing style. I honestly think I learned more about programming\n from that experience than from anything else I’ve done before or\n after.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
Probably the arrogance of the community that surrounds it. Knowing\n Lisp certainly doesn’t make one a better person, nor even\n necessarily a better programmer.
\n

\n\n

Among the software projects you’ve participated in what’s your favorite?

\n\n

\n
Definitely RethinkDB. We took a really complex subject (real-time\n distributed systems) and made them extremely accessible and\n super-easy to use. I love the product both because we made the user\n experience a joy, and because of the really advanced technology that\n goes inside to make that happen (from low-level assembly hacks, all\n the way up to abstract mathematics).
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
I’d want to build my own Lisp dialect. I know, I know, it’s been\n done to death, there is no need to do it, and it only hurts the\n community, but in the presence of infinite time, it’s just too much\n fun not to do.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
The most important thing I learned on productivity is this Alan Kay\n quote:
\n

\n\n

\n
\n
Perspective is worth 80 IQ points.
\n
\n

\n\n

\n
You could be the most productive person in the world, but it won’t\n make the slightest bit of difference if you’re pointing your talents\n in a direction that isn’t useful to other people. If you’re\n talented, your gift is precious and your time is limited. Learn how\n to direct your talents, it will be the most important thing you do.
\n

\n\n

You’re currently a co-founder of a startup company RethinkDB, which went through YCombinator. As an insider of the startup ecosystem, in your opinion, what are the areas for Lisp use in startups nowadays with the biggest potential upside and why?

\n\n

\n
This isn’t a popular stance in the Lisp community, but I think that\n today Lisp is mostly valuable as an education tool, as a means of\n thinking, and as an engine of ideas. It’s very important for\n that. But as far as practical use goes, there are better options today.
\n

\n\n

\n $\"Slava\"$

Slava

\n\n

2012-10-25

\n\n

Pascal Costanza (Germany - Belgium)

\n\n

Pascal Costanza is a researcher, and an active Common Lisp programmer and community enthusiast:

\n\n

he’s the maintainer of\nCloser to MOP library,\nthat provides a common facade to the MOP implementation in different\nLisps, and is the basis of some of his more advanced libraries like:\nContextL and\nFiltered Functions;
the originator of\nCommon Lisp Document Repository (CDR)\nproject, that collects proposals for improving the language (a la\nJCP for Java or PEP for Python);
and the author of a\nHighly Opinionated Guide to Lisp,\nwhich can serve as introductory text for those who come to Lisp from other\nlanguages. (It was quite a useful text for me, when I started\nstudying Lisp.)

In the interview Pascal shares a lot if insight into his main topic of interest — programming language design — grounded in his experience with Lisp, Java, C++ and other languages.

\n\n

His twitter is @infoxpascal

\n\n

Tell us something interesting about yourself.

\n\n

\n
I share a birthday with Sylvester Stallone and George W. Bush.\n I have been a DJ for goth and industrial music in the Bonn/Cologne\n area in Germany in the past. I once played a gay Roman emperor in\n comedic theatre play. I played a few live shows with a band called\n “Donner über Bonn” (“Thunder over Bonn”). My first rock concert I\n ever attended was Propaganda in Cologne in 1985. The first\n programming language I really liked was Oberon. I often try to hide\n pop culture references in my scientific work, and I wonder if\n anybody ever notices. My first 7” single was “Major Tom” by Peter\n Schilling, my first 12” single was “IOU” by Freeez, my first vinyl\n album was “Die Mensch-Maschine” by Kraftwerk, and my first CD album\n was “Slave to the Rhythm” by Grace Jones. I don’t remember what my\n first CD single was.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I currently work for Intel, a company whose primary focus is on\n producing CPUs, but that also does business in a lot of other\n hardware and software areas. (Unfortunately, Intel’s legal\n department requires me to mention that the views expressed in this\n interview are my own, and not those of my employer.)
\n\n
I work in a project that focuses on exascale computing, that is,\n high-performance computers with millions of cores that will be on\n the market by the end of the decade, if everything goes well. I am\n particularly involved in developing a scheduler for parallel\n programs that can survive hardware failures, which due to the\n enormous scale of such machines cannot be solved by hardware alone\n anymore, but also need to be dealt with at the software level. The\n scheduler is based on\n Charlotte Herzeel’s\n PhD thesis, and you can find more information about it in\n a paper about her work\n and at http://www.exascience.com/cobra/.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
At Intel, I do all software prototyping in Lisp. The scheduler I\n mentioned above is completely developed and tested in Lisp, before\n we port it to C++, so that other people in the same project and\n outside can use it as well. It didn’t require a major effort to\n convince anybody to do this in Lisp. It is actually quite common in\n the high-performance computing world that solutions are first\n prototyped in a more dynamic and flexible language, before they are\n ported to what is considered a “production” language. Other\n languages that are used in our project are, for example, MATLAB,\n Python and Lua. (Convincing people to use Lisp beyond prototyping\n would probably be much harder, though.)
\n\n
The implementation we use for prototyping is LispWorks, which is\n really excellent. It provides a really complete, well-designed and\n efficient API for parallel programming, which turns LispWorks into\n one of the best systems for parallel programming of any language,\n not just in the Lisp world. The only other system that is more\n complete that I am aware of is Intel’s Threading Building Blocks for\n C++.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
I have participated in one of the first Feyerabend workshops,\n organized by Richard Gabriel, one of\n the main drivers behind the original Common Lisp effort. I have also\n read his book\n Patterns of Software\n around that time. Later we had a small discussion in the patterns\n discussion mailing list. He tried to promote Lisp as a language that\n has the “quality without a name”, and I made some cursory remarks\n about Lisp’s unnecessarily complicated syntax, just like anybody\n else who doesn’t get it yet.
\n\n
To me, the most important comment he made in that discussion was:
\n\n
\n
True, only the creatively intelligent can prosper in the Lisp\n world.
\n
\n\n
The arrogance I perceived in that comment annoyed me so much\n that it made me want to learn Lisp seriously, just to prove him\n wrong and show him that Lisp is not as great as he thought it is. As\n they say, the rest is history.
\n\n
I actually dabbled a little bit in Lisp much earlier, trying out a\n dialect called XLisp on an Atari XL computer at the end of the\n 80’s. Unfortunately, it took too long to start up XLisp, and there\n was not enough RAM left to do anything interesting beyond toy\n examples, plus I was probably not smart enough yet to really get\n it. I was just generally curious about programming languages. For\n example, I also remember trying out some Prolog dialect on my Atari\n XL.
\n\n
In the end, Lisp won me over because it turns out that it is the\n mother of all languages. You can bend it and turn it into whatever\n language you want, from the most flexible and reflective interpreted\n scripting language to the most efficient and static compiled\n production system. For example, the scheduler mentioned above easily\n gets in the range of equivalent C/C++-based schedulers (like Cilk+,\n TBB, or OpenMP, for example), typically only a factor of 1.5 away\n for typical benchmarks, sometimes even better. On the other hand,\n ContextL uses the reflective features of the CLOS Metaobject\n Protocol to bend the generic function dispatch in really extreme\n ways. I am not aware of any other programming language that covers\n such a broad spectrum of potential uses.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
When I decided to make a serious attempt at learning Common Lisp,\n I was looking for a project that would be large enough to prove to\n myself that it is actually possible to use it for serious projects,\n but that would also be manageable in a reasonable amount of time.\n At that time, I was intimately familiar with the Java Virtual Machine\n architecture, because I had developed compilers for Java language\n extensions as part of my Diploma and PhD theses. So I decided to\n implement a Java Virtual Machine in Common Lisp - under normal\n circumstances, I wouldn’t have dared to do this, because this is\n quite a complex undertaking, but I had read in several places that\n Lisp would be suitable for projects that you would normally not dare\n to do otherwise, so I thought I would give it a try. Over the course\n of 8 weeks, with something like 2 hours per day, or so (because I\n was still doing other stuff during the day), I was able to get a\n first prototype that would execute a simple \"Hello, World!\"\n program. On top of that, it was a portable (!) just-in-time\n compiler: It loaded the bytecode from a classfile, translated it\n into s-expressions that resemble the bytecodes, and then just called\n Common Lisp’s compile function to compile those s-expressions,\n relying on macro and function definitions for realizing these\n “bytecodes as s-expressions.” I was really impressed that this was\n all so easy to do.
\n\n
The real moment of revelation was this: to make sure to reuse as\n many of the built-in Common Lisp features as possible, I actually\n translated Java classes into CLOS classes, and Java methods into\n CLOS methods. Java’s super calls posed a problem, because it was not\n straightforward to handle super calls with plain call-next-method\n calls. Then I discovered user-defined method combinations, which\n seemed like the right way to solve this issue, but I was still stuck\n for a while. Until I discovered that moving a backquote and a\n corresponding unquote around actually finally fixed everything. That\n was a true Eureka moment: In every other programming language that I\n am aware of, all the problems I encountered until that stage would\n have required a dozen redesigns, and several attempts to start the\n implementation completely from scratch, until I would have found the\n right way to get everything in the right places. But Common Lisp is\n so flexible that at every stage in your development, you can tweak\n and twist things left and right, but in the end you still get a\n convincing, clean, and efficient design. As far as I can tell, this\n is not possible in any other language (not even Scheme).
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
There is not much to dislike about Lisp itself. There are some\n technical details here and there, some minor inconsistencies, but\n nothing that cannot be fixed in easy and straightforward ways. From\n a purely conceptual point of view, Common Lisp is one, if not the\n most complete and best integrated programming language that covers a\n lot of ground. Some rough edges are just to be expected, because\n nothing is ever perfect.
\n\n
What concerns me a lot more is that there is too much unwarranted\n arrogance in the Lisp community. I don’t know exactly where this\n comes from, but some Lispers seem to believe, just because they\n understand some Lisp concepts, that they are much smarter than\n anybody else in the universe. What they are forgetting is that\n computer science as a discipline is very, very young. In one or two\n hundred years from now, Lisp concepts will be common knowledge, just\n like elementary algebra. There is no reason to be arrogant just\n because you know that the earth is round, even if most other people\n still believe that it is flat.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
I strongly believe that the one thing that made me most productive\n as a programmer is my interest in doing some form of art. I used to\n spend a lot of time making my own music, both by myself with\n synthesizers and computers, as well as in bands. I also was an actor\n in an amateur theater group. Art gives you a sense of making parts\n (notes, chords, melodies, rhythms, or acts, characters, plot lines)\n relate to each other and form a coherent whole. It also makes you\n aware that there is an inner view on a piece of music or a play, as\n seen by the artist, but also an outer view, as seen or heard by an\n audience, and if you want to make good art, you need to be able to\n build a bridge between those two parts.
\n\n
Programming is exactly the same: you need to make parts (functions,\n data structures, algorithms) relate to each other, and you need to\n bridge the inner view (as seen by the designer and implementer) and\n the outer view (as seen by the user of a library or the end user of\n the final software).
\n\n
The important aspect here is that you need to be able to change\n perspectives a lot, and shift between the local, detailed view, the\n global, architectural view, and the many different levels of a\n layered design. This is especially important when it comes to\n designs that incorporate meta-programming techniques and reflective\n approaches, but also already for simpler designs.
\n\n
Like in art, the concrete workflow and the concrete tools that work\n best vary a lot for different people. It’s also a good idea to just\n play around with ideas, expecting that most of them will turn out\n useless and need to be thrown away. Artists do this all the\n time. Artificial, seemingly nonsensical rules and restrictions can\n be especially enlightening (use only effect-free functions; use only\n functions that receive exactly one argument, not more, not less;\n make every function pass around an additional environment; use only\n classes with exactly two slots; etc., etc.), and then try to build\n larger programs strictly following such rules - this will make your\n mind a lot more flexible and train you to see new potential\n solutions that you wouldn’t see otherwise.
\n\n
(I actually believe that this is what makes fans of static typing so\n excited: Static type systems always impose some artificial\n restrictions on your programs, and enforce them to the extent that\n programs that violate these rules are rejected. If you then program\n in such a statically typed programming language, you will indeed\n have some interesting insights and see new solutions that you would\n otherwise miss. However, the category error that fans of static\n typing often seem to make is that they ascribe the results to the\n static type system, and therefore usually get stuck with one\n particular set or kinds of rules.)
\n\n
Apart from that, I believe that LispWorks is a really good\n development environment.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
I don’t know how to answer that. At any point in time, I’m always\n most excited by the one I’m currently working on. So far, I am quite\n proud of ContextL the ClassFilters project for Java, because they\n are or were both used in one way or the other in “real”\n applications. Closer to MOP is a favorite project of mine, because\n it makes me feel like I can give something back to the Lisp\n community from which I otherwise benefit so much. But this doesn’t\n mean I dislike anything else I have done in the past.
\n

\n\n

One of your papers, “Reflection for the Masses”, researches the ideas behind 3-Lisp, “a procedurally reflective dialect of LISP which uses an infinite tower of interpreters”. Can you summarize them here?

\n\n

\n
That paper was actually mostly the work of Charlotte Herzeel, and I\n was only her sounding board for detailing the ideas in that\n paper. Reflection is one of the essential concepts that was born out\n of Lisp. Every program is about something, for example a financial\n application is about bank accounts, money and interest rates, and a\n shopping application is about shopping items, shopping carts and\n payment methods. A program can also be about programs, which turns\n it into a meta-program. Lisp macros are meta-programs, because they\n transform pieces of code in the form of s-expressions into other\n pieces of code. C++ templates are also meta-programs in the same\n sense. Some meta-programs are about “themselves,” and thus become\n reflective programs.
\n\n
3-Lisp is “procedurally reflective” in two senses: On the one hand,\n it allows you to inspect and change the body of procedures\n (functions). Common Lisp, for example, also gives you that, in the\n form of function-lambda-expression and compile/eval, among\n others. On the other hand, 3-Lisp also allows you to inspect and\n alter the control flow. Scheme, for example, gives you that in the\n form of call/cc, but in 3-Lisp this is actually part of the eval\n interface. 3-Lisp goes further than Common Lisp and Scheme combined,\n in that it provides not only first-class access to function bodies\n and continuations, but also to lexical environments, always both\n with facilities to inspect and modify them, and provides a clean and\n integrated interface to all of these features. Unfortunately,\n because 3-Lisp goes that far, it cannot be fully compiled but always\n needs to be able to resort to interpretation, if necessary.
\n\n
The reason for the requirement to always have an interpreter around\n is because the eval interface in 3-Lisp is so flexible that you can\n run programs inside an eval invocation that in turn can inspect and\n change (!) the environment in which eval runs, and can then invoke\n further evals in those changed environments, to arbitrary levels of\n recursive invocations of eval. These recursive invocations of eval\n build what is called a reflective tower, where every level in the\n tower is conceptually an interpreter being executed by an\n interpreter one level up in the tower of interpreters. The amazing\n thing about 3-Lisp is that an implementation of 3-Lisp can actually\n collapse the tower into one level of interpretation, and arrange\n that one interpreter in such a way that several different levels\n of interpretations are only simulated, so the tower is actually just\n an “illusion” created by the 3-Lisp implementation.
\n\n
This may all sound quite esoteric, but is actually practically\n relevant, because there is strong evidence that all meta-programming\n approaches eventually need such towers, and some ad-hoc way to\n collapse the towers. For example, you can find the tower in Racket’s\n and R6RS’s macro systems, where they are explicitly mentioned; in\n Common Lisp’s macros, where eval-when is used to control which part\n of the tower sees which definitions; in the CLOS Metaobject\n Protocol, where the generic function dispatch can be influenced by\n other generic functions, which can in turn be modified by some\n meta-classes at a higher level; in the template metaprogramming\n system of C++, where “concepts” were devised for C++11 (and\n rejected) to introduce a type system for the template interpreter;\n and so on, and so on. If you understand the concept of a reflective\n tower better, you can also better understand what is behind these\n other meta-programming approaches, and how some of their sometimes\n confusing semantic difficulties can be resolved.
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
I have some ideas how to design reflection differently for a Lisp\n dialect, which I believe has not been tried before. If I had all the\n time in the world, I would try to do that. I also have many other\n ideas, so I’m not sure if I would be able to stick to a single one.
\n

\n\n

Anything else I forgot to ask?

\n\n

\n
I think one of the most underrated and most underused Lisp dialects\n is ISLISP. I think people should take a\n much closer look at it, and should consider to use it more\n often. Especially, it would be an excellent basis for a good\n teaching language.
\n

\n\n

\n $\"Pascal\"$

Pascal

\n\n

2012-04-16

\n\n

Peter Seibel (USA)

\n\n

Peter Seibel has helped more people (including me) discover and become\nuser of Lisp as probably no one else in the last decade with his\nPractical Common Lisp. Dan\nWeinreb, one of the founders of\nSymbolics and later Chief Architect at ITA Software, a succesfull Lisp\nstartup sold to Google for around $1B in 2011, wrote, that their\nmethod of building the Lisp team was by hiring good developers and\ngiving them PCL for two weeks after which they could successfully\nintegrate under the mentorship or their senior Lisp people.

\n\n

A few years after PCL Peter went on to write another fantastic\nprogramming book Coders at Work —\nhere’s my\nsummary\nof it with the social network of Coders :)

\n\n

Aside from being a writer he was and remains a polyglot programmer,\ninterested in various aspects of our trade, about which he\nblogs occasionally. His code,\npresented in PCL, laid the foundation for a wide-spread\nCL-FAD library, which deals with filenames\nand directories (as the name implies), and more recently he created a\nLisp documentation browser\nManifest. Before Lisp\nPeter had worked a lot on Weblogic Java application server.

\n\n

His twitter is @peterseibel

\n\n

Tell us something interesting about yourself.

\n\n

\n
I’m a second generation Lisp programmer. My dad discovered Lisp when\n he was working at Merck in the 80s and ended up doing a big project\n to simulate a chemical plant in Lisp, taking over from some folks\n who had already been trying for quite a while using Fortran, and\n saving the day. Later he went to Bolt Beranek and Newman where he\n did more Lisp. So I grew up hearing about how great Lisp was and\n even getting to play around with some graphics programs on a\n Symbolics Lisp Machine.
\n\n
I was also a childhood shareholder in Symbolics—I had a little money\n from some savings account that we had to close when we moved so my\n parents decided I should try investing. I bought Symbolics because\n my parents just had. Never saw that money again. As a result, for\n most of my life I thought my parents were these naive, clueless\n investors. Later I discovered that around that time they had also\n invested in Microsoft which, needless to say, they did okay with.
\n\n
Oh, and something I learned recently: not only was Donald Knuth one\n of the subjects in my book Coders at Work, but he has read the whole\n thing himself and liked it. That makes me happy.
\n

\n\n

What’s your job? Tell us about your organization.

\n\n

\n
A few months ago I started working half-time at Etsy. Etsy is a\n giant online marketplace for people selling handmade and vintage\n items and also craft supplies. I’m in the data group where we try to\n find clever ways to use data to improve the web site and the rest of\n the business.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
I always have a SLIME session going in Emacs for quick computations\n and sometimes I prototype things in Lisp or write code to experiment\n with different ideas. However, these days I’m as likely to do those\n things in Python because I can show my co-workers a sketch written\n in Python and expect them to understand it and I’m not sure I could\n do that with Lisp. But it makes me sad how slow CPython is compared\n to a native-compiling CL like SBCL. Usually that doesn’t matter but\n it is annoying sometimes mostly because Python has no real\n excuse. The rest of my work is in some unholy mishmash of Scala,\n Ruby, Javascript, and PHP.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
As I mentioned, I grew up hearing from my dad about this great\n language. I actually spent a lot of my early career trying to\n understand why Lisp wasn’t used more and exploring other languages\n pretty deeply to see how they were like and unlike Lisp. I played\n around with Lisp off and on until finally in 2003 I quit the startup\n I had been at for three years, which wasn’t going anywhere, with a\n plan to take a year off and really learn Common Lisp. Instead I\n ended up taking two years off and writing Practical Common Lisp.
\n\n
At this point I use it for things when it makes sense to do so\n because I know it pretty well and most of my other language chops\n are kind of rusty. Though I’m sure my CL chops are rusty too,\n compared to when I had just finished PCL.
\n

\n\n

Did you ever develop a theory why Lisp isn’t used more?

\n\n

\n
Not one that is useful in the sense of helping it to be used more\n today. Mostly it seems to me to be the result of a series of\n historical accidents. You could argue that Lisp was too powerful too\n early and then got disrupted, in the Innovator’s Dilemma sense, by\n various Worse is Better languages, running on systems that\n eventually became dominant for perhaps unrelated reasons.
\n\n
Every Lisper should read\n The UNIX-HATERS Handbook\n to better understand the relation between the Lisp and Unix\n cultures—Lisp is the older culture and back when the UNIX-HATERS\n Handbook was written, Unix machines were flaky and underpowered and\n held in the same contempt by Lisp geeks as Windows NT machines would\n be held by Unix geeks a few decades later. But for a variety of\n reasons people kept working on Unix and it got better.
\n\n
And then it was in a better position than the Lisp culture to\n influence the way personal computing developed once micro computers\n arrived—while it would be a while before PCs were powerful enough to\n run a Unix-like OS, early on C was around to be adopted by PC\n programmers (including at Microsoft) once micros got powerful enough\n to not have to program everything in assembly. And from there,\n making things more Unix-like seemed like a good goal. Of course it\n would have been entirely possible to write a Lisp for even the\n earliest PCs that probably would have been as performant as the\n earliest Lisps running on IBM 704s and PDP-1s. My dad, back from his\n Lisp course at Symbolics, wrote a Lisp in BASIC on our original IBM\n PC. But by that point Lispers’ idea of Lisp was what ran on powerful\n Lisp machines, not something that could have run on a PDP-1.
\n\n
The AI boom and bust played its role as well because after the bust\n Lisp’s reputation was so tainted by its failure to deliver on the\n over-promises of the Lisp/AI companies that even many AI researchers\n disassociated themselves from it. And throughout the 90s various\n languages adopted some of Lisp’s dynamic features, so folks who\n gravitated to that style of programming had somewhere else to go and\n then when the web sprang into prominence, those languages were well\n positioned to become the glue of the Internet.
\n\n
That all said, I’m heartened that Lisp continues to not only be used\n but to attract new programmers. I don’t know if there will ever be a\n big Lisp revival that brings Lisp back into the mainstream. But even\n if there were, I’m pretty sure that there would be plenty of\n old-school Lispers who’d still be dissatisfied with how the revival\n turned out.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
I’m pretty proud of the tool chain I’ve built over the years while\n writing my two books and editing the magazine I tried to start, Code\n Quarterly. When I first started working on Practical Common Lisp I\n had some Perl scripts that I used to convert an ad-hoc light-weight\n text markup language into HTML. But after a little while of that I\n realized both that Jamie Zawinski was right\n about regexps and that of course I should be using Lisp if I was\n writing a book called Practical Common Lisp.
\n\n
So I implemented a proper parser for a mostly-plain-text language\n that I uncreatively call Markup and backends that could generate\n HTML and PDF using\n cl-typesetting.\n When I was done writing and Apress wanted me to turn in Word files,\n I wrote an RTF backend so I could generate RTF files with all the\n Apress styles applied correctly. An Apress project manager later\n exclaimed over how “clean” the Word files I had turned had been.\n For editing Code Quarterly I continued to use Markup and wrote a prose\n diff tool that is pretty smart about when chunks of text get moved\n and edited a little bit.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
I don’t know if “dislike” is the right term because the alternative\n has its own drawbacks. But I do sometimes miss the security of\n refactoring with more static checks. For instance, when I programmed\n in Java, there was nothing better than the feeling of knowing a\n method was private and therefore I didn’t have to look anywhere but\n in the one file where the method lived to see everywhere it could\n possibly be used. And in Common Lisp the possibilities for action at\n a distance are even worse than in some other dynamic languages\n because of the loose relation between symbols and the things they\n name. In practice that’s not actually a huge problem and some\n implementations provide package locks and so on, but it always makes\n me feel a bit uneasy to know that if I :use a package and then\n DEFUN a function with the name of an inherited symbol I’ve changed\n some code I really didn’t mean to.
\n\n
From time to time I imagine a language that lets you write\n constraints on your code in the language yourself—kind of like\n macros but instead of extending the syntax your compiler\n understands, they would allow you to extend the set of things you\n could say about your code that the compiler would then\n understand. So you could say things like, “this function can only be\n called from other functions in this file” but also anything else\n about the static structure of your code. I’m not sure exactly what\n the API for saying those things would look like but I can imagine it\n being pretty useful, especially in larger projects with lots of\n programmers: you could establish certain rules about the overall\n structure of the system and have the compiler enforce them for\n you. But then if you want to do a big refactoring you could comment\n out various rules and move code around just like in a fully dynamic\n language. That’s just a crazy idea; anyone who’s crazy in the same\n way should feel free to take it and run with it and see if they get\n anywhere.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
Probably my favorite software I ever wrote was a genetic algorithm\n I wrote in the two weeks before I started at Weblogic in 1998,\n in order to build up my Java chops. It played Go and eventually got to\n the point where it could beat a random player on a 5x5 board pretty\n much 100% of the time. One of these days I need to rewrite that\n system in Common Lisp and see if I can work up to a full-size board\n and tougher opponents than random. (During evolution the critters\n played against each other to get a Red Queen effect—I just played\n them against a random player to see how they were doing.)
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers

\n\n

\n
I’m not sure I’m so productive I should be giving anybody tips. When\n I’m writing new code I tend to work bottom up, building little bits\n that I can be confident in and then combining. This is obviously\n easy to do in a pretty informal way in Common Lisp. In other\n languages unit tests can be useful if you’re writing a bigger system\n though I’m often working on things for myself that are small enough\n I can get away with testing less formally. (I’m hopeful that\n something like Light Table will allow the easy of informal testing\n with the assurances of more strict testing—I’d love to have a\n development environment that keeps track of what tests go with what\n production code and shows them together and runs the appropriate\n tests automatically when I change the code.)
\n\n
When I’m trying to understand someone else’s code I tend to find the\n best way is to refactor or even rewrite it. I start by just\n formatting it to be the way I like. Then I start changing names that\n seem unclear or poorly chosen. And then I start mucking with the\n structure. There’s nothing I like better than discovering a big\n chunk of dead code I can delete and not have to worry about\n understanding. Usually when I’m done with that I not only have a\n piece of code that I think is much better but I also can understand\n the original. That actually happened recently when I took Edi\n Weitz’s Hunchentoot web server and\n started stripping it down to create\n Toot (a basic web server) and\n Whistle (a more user\n friendly server built on top of Toot). In that case I also discarded\n the need for backward compatibility which allowed me to throw out\n lots of code. In that case I wasn’t going for a “better” piece of\n code so much as one that met my specific needs better.
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
I should really get back to hacking on Toot and Whistle. I tried to\n structure things so that all the Hunchentoot functionality could be\n put back in a layer built on top of Toot—perhaps I should do that\n just to test whether my theory was right. On the other hand, I went\n down this path because the whole Hunchentoot API was too hard for me\n to understand. So maybe I should be getting Toot and Whistle stable\n and well-documented enough that someone else can take on the task of\n providing a Hunchentoot compatibility layer.
\n\n
I’d also like to play around with my Go playing critters,\n reimplementing them in Lisp where I could take advantage of having a\n to-machine-code compiler available at run time.
\n

\n\n

PCL was the book, that opened the world of Lisp to me. I’ve also greatly enjoyed Coders at Work. So I’m looking forward for the next book you’d like to write. What would it be? :)

\n\n

\n
My current theory is that I’m going to write a book about statistics\n for programmers. Whenever I’ve tried to learn about statistics\n (which I’ve had to do, in earnest, for my new job) I find an\n impedance mismatch between the way I think and the way statisticians\n like to explain stuff. But I think if I was writing for programmers,\n then there are ways I could explain statistics that would be very\n clear to them at least. And I think there are lots of programmers\n who’d like to understand statistics better and may have had\n difficulties similar to mine.
\n

\n\n

\n $\"Peter\"$

Peter

\n\n

2012-07-01

\n\n

Marijn Haverbeke (Netherlands - Germany)

\n\n

Marijn Haverbeke is not only the author of several pretty useful\nCommon Lisp libraries (some of which he\ntouches in the interview), but also a succesful JavaScript hacker,\nwinning JS1K contest, and writing a\nprofound book about the language —\n“Eloquent JavaScript”. Besides, he\nhacks on Mozilla Rust and his own language Hob, not to mention\nco-authoring a JavaScript-to-Common-Lisp transpiler, writing some\ngames in Scheme, and experimenting with Haskell. In the interview he\nshares his perspective based in knowledge and experience with so many\ndifferent languages.

\n\n

His twitter is @marijnjh

\n\n

Tell us something interesting about yourself.

\n\n

\n
I once thought I wanted to be a Sociologist. Before that, I also\n once thought that I wanted to become a treasure hunter. And a\n dinosaur researcher. I ended up a programmer, largely self-taught,\n and I’m very happy with how things turned out.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I’m working free-lance. Currently, I’m doing a lot of work for\n Mozilla, hacking on their Rust\n compiler. Rust is a programming language that’s supposed to fit the\n C++ niche, without the insanity of actual C++. If the project works\n out, and it’s going swimmingly so far, Mozilla will try to apply it\n to writing a next-generation browser, without the constant danger of\n buffer overrun exploits and threading bugs that comes with C++. True\n to Mozilla’s spirit, all development on Rust is happening in the\n open, on github.
\n\n
Another things I’m busy with is my own\n CodeMirror project, a code editor written\n in JavaScript. It’s not a ‘job’, really, since it’s open-source and\n no one is paying me to maintain it, but it’s grown popular enough to\n generate a decent amount free-lancing gigs and a small income stream\n from support contracts.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
Not currently, beyond that I always have a REPL open in emacs, and\n switch to it to do quick computations and experiments. I’ve spent\n several years doing almost exclusively Lisp (mostly working on\n AllegroGraph, Franz’\n RDF database), and it has definitely been somewhat painful to find\n myself working with non-interactive, macro-less languages again,\n after being used to the luxuries of Common Lisp and Slime.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
Ten years ago, during my sociology study, I randomly chose a Lisp\n course in university. I was spending so much time in emacs that I\n figured I might as well learn more about its scripting language. The\n course worked through\n Structure and Interpretation of Computer Programs,\n using the video lectures from Abelson and Sussman. Having been\n exposed mostly to Java, C++, and Python before that, the elegance\n and depth of this material was something of a revelation to me.
\n\n
My professor for that course, Eduard Hoenkamp, was a real Lisp\n chauvinist with an MIT background, and properly indoctrinated me\n with regards to Lisp’s glorious superiority. I wrote a text\n adventure game in Scheme for the end project of the course, my first\n non-trivial Lisp endeavor. I still have the\n code. I ended up starting a\n PhD with this very professor, and though I never finished it, it did\n provide me with ample opportunity to learn Common Lisp.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
I think that’d be\n CL-JavaScript, a\n JavaScript-to-Common-Lisp transpiler that I wrote together with a\n friend. It actually handles the whole ECMAScript 3 language and\n produces programs that run reasonably fast—about on par with the\n 2009 generation of browser JavaScript engines. This is quite\n amazing, given that it’s less than 4000 lines of code, at least an\n order of magnitude smaller than those engines. The Lisp compiler\n handles most of the optimization for us. (I should point out that\n the browser JS engines have a much higher speed of compilation,\n which is a necessity for handling web content.)
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
I must say that the lack of static typing really gets in the way on\n larger projects. Being able to confidently change datatypes and\n function signatures, knowing that the compiler will point out most\n inconsistencies that you introduce, is something that I’ve really\n come to appreciate after working with Rust and Haskell. Test\n coverage helps, of course, but I’m not a very diligent test writer,\n and tend to feel that type signatures are easier to maintain than an\n exhaustive test suite.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
My approach to writing software is embarrassingly unstructured. I’m\n not sure I can claim to have something that merits the term\n “workflow”. One thing that is very important for me, and that, had I\n figured it out earlier, would probably have saved some past projects\n from dying, is to never have a system in a half-refactored,\n non-functional state for longer than an hour or so. A lot of\n momentum and motivation comes from having a working program in front\n of me. This sometimes means I have to split up big changes in a\n number of more indirect, trivial steps, and resist the temptation to\n start hammering out my big change in one go (which, even when seems\n straightforward in my head, will always hit some complications\n during implementation).
\n\n
Also, really learning git in depth has had a big influence on how I\n code. Once you really understand that changes (if you bother to\n commit often and with care) can be reverted and picked at will, and\n that branches are cheap and easy to create and maintain, you start\n to see a codebase differently. I often take multiple shots at making\n a tricky change — if it feels like my first approach is not working\n out, I simply commit it, back up, and start again, knowing that if\n the new approach doesn’t work out, I can simply flip back to the old\n one again. Knowing that this is theoretically possible is not\n enough—you need to have actually done it, often, to start applying\n it properly.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
Postmodern, the PostgreSQL\n client, was my first non-trivial open-source project, and the first\n piece of actually useful software that I designed and executed on my\n own. I was extremely proud when I got it to work the way I wanted\n (modular, fast), and meticulously wrote out a long set of docs\n (copying Edi Weitz’s style). Seeing people actually use it (and even\n write good things about it!) really drove home for me the fact that\n it is worthwhile and rewarding to package up the stuff I write, and\n share it.
\n\n
The community involvement in Postmodern, though always low-volume,\n has also been awesome. Most bug reports came with a patch, or at\n least an informed view of the problem and useful diagnostic\n information. This in sharp contrast with the JavaScript community,\n where of course great contributors also occur, but one has to deal\n with a lot of noise and lazy bug reporting.
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
I am working on my own programming language,\n Hob, which tries to combine the\n virtues of Lisp and ML. This is a huge project, and unfortunately\n it’s moving forward only slowly. If I didn’t have financial\n constraints, I’d spend a year (or two) finishing it. Its “bootstrap\n compiler” (the compiler that will compile the first self-hosting\n compiler) is in the process of being written in Common Lisp. The\n writing that I currently have online about it is quite old and out\n of date. I just spent a week rewriting the compiler from scratch,\n moving the language to a completely regular syntax—think\n s-expressions, though Hob looks somewhat different. My work on Rust\n has convinced me that, even with all the good will in the world, you\n can’t bolt macros onto a classical language with a non-regular\n syntax without making them very painful to write (and use!). They\n have to be part of the design from the start.
\n

\n\n

You’ve been actively using Common Lisp and JavaScript. When you use JavaScript what do you miss the most from CL? What do you miss from JavaScript when you’re in Lisp land?

\n\n

\n
The greatest thing about Common Lisp is that the standardization\n process drew from years and years of experience and organic\n growth. This makes the language feel singularly solid and\n practical. Most languages feel immature compared to CL. I suspect\n that this is not just age, but also the fact that Lisp allows users\n to extend the language to an unprecedented degree, which allows for\n much more experimentation, and thus faster growth and invention.
\n\n
The great thing about JavaScript is that it has so few concepts. It\n manages to strike a balance between being dumbed-down enough to be\n easy to grasp, which has allowed it to become as widespread as it\n currently is, and still being a more-or-less decent lambda language,\n which makes it scale up to complex programs relatively well. It is\n on its way to become a lingua franca of scripting, which Common Lisp\n will never be, because it is much more demanding of its\n programmers—they need to understand a lot more concepts.
\n

\n\n

2012-04-02

\n\n

François-René (Faré) Rideau (France - USA)

\n\n

François-René Rideau works at ITA Software, one of the largest\nemployers of lispers, which was acquired by Google a year ago. While\nat ITA he stepped up to support and improve\nASDF, the system definition\nfacility, that is at the core of Lisp package distribution. He’s also\nthe co-author of the recently published Google Common Lisp Style\nGuide,\nwhich as well originated at ITA.

\n\n

Faré is also an active writer: both of code and prose. He’s thoughts\nand articles can be found on\nFacebook,\nGoogle+,\nLivejournal, and his\nsite.

\n\n

His twitter is @fare

\n\n

Tell us something interesting about yourself.

\n\n

\n
I like introducing myself as a cybernetician: someone interested in\n the dynamic structure of human activities in general.
\n\n
Programming languages and their semantics, operating systems and\n reflection, persistence of data and evolution of code, the relation\n between how programmers are organized and what code they produce —\n these are my topics of immediate professional interest. For what\n that means, see for instance my slides (improved) from ILC’09:\n “Better Stories, Better Languages”\n or my essay\n “From Creationism to Evolutionism in Computer Programming”.
\n\n
However I’m also interested in cybernetics as applies to\n Civilization in general, past, present and future. See for instance\n my essay\n “Identity, Immunity, Law and Aggression on the Rapacious Hardscrapple Frontier”\n or my writings about\n Individual Liberty and the basic\n principles of Economics
\n\n
Last but not least, I was recently married to my love Rebecca\n Kellogg, with whom I have since had a daughter Guinevere Lý “Véra”\n Kellogg Rideau (born last May). This gives me less free time, yet\n somehow made me more productive.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
For the last 7 years or so, I have been working at ITA Software, now\n part of Google Travel. I have been working on two servers written in\n Lisp, at first briefly on QPX the\n low (air)fare search engine behind Orbitz and Google Flights then\n mostly on QRes, a reservation system now launched with Cape\n Air. These projects nowadays each count about half a million lines\n of Common Lisp code (though written in very different styles), and\n each keep growing with tens of active developers.
\n\n
I suspect that my login “fare” (at itasoftware) was a pun that\n played in favor of recruiting me at ITA; however, it wasn’t\n available after the Google acquisition, so now I’m “tunes” (at\n google), to remind myself of my TUNES project.
\n\n
At ITA, I have been working mostly on infrastructure:
\n\n
\n
how to use better compilers (moving from CMUCL to SBCL, CCL),
\n
how to build, run and test our software,
\n
how to maintain the free software libraries we use and sometimes write,
\n
how to connect QRes to QPX and follow the evolution of its service,
\n
how to persist objects to a robust database,
\n
how to migrate data from legacy systems,
\n
how to upgrade our software while it’s running, etc.
\n
\n
And debugging all of the above and more, touching many parts of the\n application itself along the way.
\n\n
I think of my job at ITA so far as that of a plumber: On good days,\n I design better piping systems. On bad days, I don gloves and put my\n hands down the pipes to scrub.
\n\n
Since you’re mentioning me as working at ITA and on ASDF, I suppose\n it is appropriate for me to tell that story in full.
\n\n
In building our code at ITA, we had grown weary of ASDF as we had\n accumulated plenty of overrides and workarounds to its\n unsatisfactory behavior. Don’t get me wrong: ASDF was a massive\n improvement over what existed before (i.e. mk-defsystem), making it\n possible to build and share Common Lisp software without massive\n headaches in configuring each and every library. We have to be\n grateful to Dan Barlow indeed for creating ASDF. But the Common Lisp\n ecosystem was dysfunctional in a way that prevented much needed\n further improvements to ASDF. And so I started working on a\n replacement, XCVB.
\n\n
Now, at some point in late 2009, I wrote a rant explaining why ASDF\n could not be saved:\n “Software Irresponsibility”.\n The point was that even though newer versions of ASDF were written that\n slowly addressed some issues, every implementation stuck to its own\n version with its own compatibility fixes; no vendor was interested\n in upgrading until their users would demand upgrades, and users\n wouldn’t rely on new features and bug fixes until all vendors\n upgraded, instead caring a lot about bug-compatibility, in a vicious\n circle of what I call “Software Irresponsibility”, with no one in\n charge, consensus required for any change, no possible way to reach\n consensus, and everyone discouraged.
\n\n
However, I found a small flaw in my condemnation of ASDF as\n unsalvageable: if, which was not the case then, it were possible to\n upgrade ASDF from whichever version a vendor had installed to\n whichever newer version you cared for, then ASDF could be\n saved. Users would be able to rely on new features and bug fixes\n even when vendors didn’t upgrade, and vendors would have an\n incentive to upgrade, not to stay behind, even if their users didn’t\n directly demand it. The incentive structure would be\n reversed. Shortly after I wrote this rant, the current ASDF\n maintainer stepped down. After what I wrote, I felt like the honest\n thing to do was to step forward. Thus, I started making ASDF\n self-upgradable, then massively improved it, notably making it more\n robust, portable, and easy to configure — yet fully backwards\n compatible. I published it as ASDF 2 in 2010, with the help of many\n hackers, most notably\n Robert Goldman,\n and it has quickly been adopted by all active Common Lisp vendors.
\n\n
You can read about ASDF and ASDF 2 in the article I wrote with\n Robert Goldman for ILC 2010:\n “Evolving ASDF: More Cooperation, Less Coordination”. I’m\n also preparing a talk at ILC 2012 where I’ll discuss recent\n enhancements. I have to admit I didn’t actually understand the fine\n design of ASDF until I had to explain it in that paper, thanks to\n the systematic prodding of Robert Goldman. Clearly explaining what\n you’re doing is something I heartily recommend to anyone who’s\n writing software, possibly as a required step before you declare\n your software complete; it really forces you to get the concepts\n straight, the API clean, and the tests passing. That also did it for\n me with my more recent\n lisp-interface-library,\n on which I’m presenting a paper at ILC 2012:\n “LIL: CLOS reaches higher-order, sheds identity, and has a transformative experience”.
\n\n
One double downside of ASDF 2 is that it both took a lot of\n resources I didn’t put in XCVB, and made for a much better system\n for XCVB to try to disrupt. It isn’t as easy anymore to be ten times\n better than ASDF. I still hope to complete XCVB some day and make it\n good enough to fully replace ASDF on all Common Lisp platforms; but\n the goal has been pushed back significantly.
\n\n
Now one important point that I want to explicitly stress is that the\n problem with ASDF was not a strictly technical issue (though there\n were many technical issues to fix), nor was it strictly a social\n issue; it was an issue at the interface between the social and the\n technical spheres, one of how our infrastructures and our incentives\n shape each other, and what kind of change can bring\n improvement. That’s the kind of issues that interest me. That’s why\n I call myself a cybernetician.
\n

\n\n

Do you use Lisp at work? If yes, how have you made it happen? If not, why?

\n\n

\n
I’ve made it happen by selection. I applied at ITA Software\n precisely because I knew (thanks to the Carl de Marcken\n article published by Paul\n Graham), that the company was using Lisp to create real-world\n software. And that’s what I wanted to do: create real-world software\n with a language I could use without wanting to kill myself every\n night because it is turning me into a pattern-expanding machine\n rather than a human involved in thinking and using macros as\n appropriate.
\n\n
\n
I object to doing things that computers can do.
\n\n
— Olin Shivers
\n
\n\n
Yet, in my tasks as a plumber, I have still spent way too much time\n writing shell scripts or Makefiles; though these languages possess\n some reflection including eval, their glaring misdesign only lets\n you go so far and scale so much until programs become totally\n unmanageable. That’s what pushed me over the years to develop\n various bits of infrastructure to do as much of these things as\n possible in Lisp instead: cl-launch,\n command-line-arguments,\n philip-jose, xcvb, asdf,\n inferior-shell.
\n\n
Interestingly, the first and the last, cl-launch and inferior-shell,\n are kind of dual: cl-launch abstracts over the many Lisp and shell\n implementations so you can invoke Lisp code from the Unix shell; it\n is a polyglot lisp and shell program that can manipulate itself and\n combine parts of itself with user-specified Lisp code to produce an\n executable shell script or a dumped binary image; I sometimes think\n of it as an exercise in “useful quining”. Inferior-shell abstracts\n over the many Lisp and shell implementations so you can invoke Unix\n shell utilities from any Lisp implementation, remotely if needs be\n (through ssh), and with much nicer string interpolation than any\n shell can ever provide; it is a classic Lisp library notably\n available through Quicklisp. With the two of them, I have enough\n Unix integration that I don’t need to write shell scripts\n anymore. Instead, I interactively develop Lisp code at the SLIME\n REPL, and have a shell-runnable program in the end. That\n tremendously improved my quality of life in many situations\n involving system administration and server maintenance.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
My first introduction to Lisp was in high school, in using the HP\n RPL on my\n trusty old HP 28C (eventually upgraded to a HP28S, with 32KB of free\n RAM instead of 4KB!). When I became student at Ecole Normale\n Supérieure, I was taught Caml-light by\n xleroy himself, I learned to\n use Emacs, and I met\n Juliusz Chroboczek who\n introduced me to Scheme and Common Lisp, continuations and\n SICP. Finally, during my vain\n efforts to gather a team to develop an operating system based on a\n higher-level language as part of the TUNES project, I have been\n introduced to Lisp machines and plenty of other interesting\n concepts.
\n\n
I use Lisp because I couldn’t bear to program without higher-order\n functions, syntactic abstraction and runtime reflection. Of all Lisp\n dialects, I use Common Lisp mainly because that’s what we use at\n work; of course a large reason why we use it at work is because it’s\n a good language for practical work. However, frankly, If I were to\n leave ITA (by Google), I’d probably stop using Common Lisp and\n instead use Racket or Maru, or maybe Factor or Slate, and try to\n bootstrap something to my taste from there.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
I remember being quite exhilarated when I first ran the philip-jose\n farmer: it was a server quickly thrown together by building\n green-threads on top of\n arnesi’s\n (delimited) continuation library for CL. With it, I could farm out\n computations over a hundred servers, bringing our data migration\n process from “way too slow” (weeks) to “within spec” (a few\n hours). It’s impressive how much you can do in Lisp and with how\n little code!
\n\n
While I released the code in philip-jose, it was never\n well-documented or made user-friendly, and I suspect no one ever\n used it for real. This unhappily includes ITA, for my code never\n made it to production: I was moved to another team, our customer\n went bankrupt, and the new team used simpler tools in the end, as\n our actual launch customer was 1/50 the size of our first prospect.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
For Lisp in general, I would say the lack of good ways to express\n restrictions on code and data. Racket has been doing great work with\n Typed Racket and Contracts; but I’m still hoping for some dialect\n with good resource management based on Linear Logic, and some\n user-extensible mechanism to define types and take advantage of\n them.
\n\n
For Common Lisp in particular, though I do miss delimited\n continuations, I would say that its main issue is its lack of\n modularity. The package system is at the same time low-level and\n inexpressive; its defsystem facilities are also lacking, ASDF 2\n notwithstanding; up until the recent success of Zach Beane’s\n Quicklisp, there wasn’t a good story to\n find and distribute software, and even now it’s still behind what\n other languages have. This is part of a vicious circle where the\n language attracts and keeps a community of developers who live\n happily in a context where sharing and reusing code is relatively\n expensive (compared to other languages). But things are getting\n better, and I have to congratulate Zach Beane once again for\n Quicklisp. I believe I’m doing my small part.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
I unhappily do not have a great history of success in software\n projects that I have actively participated in.
\n\n
However, I have been impressed by many vastly successful projects in\n which I had but a modest participation. In the Linux kernel, the\n Caml community, the Racket community, (QPX and QRes at work might\n also qualify but only to lesser degrees), there were bright people\n unified by a common language, by which I mean not merely the\n underlying computer programming language, but a vision of things to\n come and a common approach to concepts: not just architecture but\n architectonics. Another important point in these successful projects\n was Software Responsibility (as contrasted to the previously\n discussed Software Irresponsibility): there is always someone in\n charge of accepting or rejecting patches to any part of the\n system. Patches don’t linger forever unapplied yet unrejected, so\n the software goes forward and the rewarded contributors come back\n with more and/or better patches. Finally, tests. Lots of\n them. Automatically run. All the time. Proofs can do, too, though\n they are usually more expensive (now if you are going to do testing\n at the impressive\n scale of sqlite, maybe you\n should do proofs instead (see\n CPDT). I discovered, the hard way,\n that tests (or proofs) are the essential complement to programs,\n without which your programs WILL break as you modify them.
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
I would resurrect TUNES based on a Linear Lisp, itself bootstrapped\n from Racket and/or Maru.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
First, think hard and build an abstract model of what you’re\n doing. Guided by this understanding of where you’re going, code\n bottom up, write tests as you do, and run them interactively at the\n SLIME REPL; make sure what you write is working and passing all\n tests at all times. Update your abstract model as it gets pummeled\n into shape by experience. Once you’ve got the code manually written\n once or twice and detect a pattern, refactor it using macros to\n automate away the drudge so the third time is a piece of cake. Don’t\n try to write the macro until you’ve written the code manually and\n fully debugged it. Never bother with low-level optimization until\n the very end; but bother about high-level optimization early enough,\n by making sure you choose proper data structures.
\n\n
Unhappily, I have to admit I am a serial under-achiever. I enjoy\n thinking about the big picture, and I like to believe I often see it\n better and further than most people; but I have the greatest trouble\n staying on track to bring about solutions: I have so many projects,\n and only one life to maybe complete a few of them! The only way I\n can actually get a few things done, is to decompose solutions into\n small enough steps such that I can keep focused on the next one and\n get it done before the focus goes away.
\n

\n\n

A year ago Google bought ITA, which was, probably, the largest Lisp company recently. What were the biggest upsides and drawbacks of using Lisp on the scale of ITA? Does Lisp have a future inside Google?

\n\n

\n
On the upside, we certainly have been able to write quite advanced\n software that we might not have otherwise managed. A million lines\n of Lisp code, including its fair share of macros and DSLs, would be\n so many more million lines of code without the syntactic abstraction\n made possible by Lisp. However hard and expensive it was with Lisp,\n I can only imagine how many times worse it would have been with\n anything else.\nAt the top of the tech bubble in 2008, we had over fifty Lisp\n programmers working just on QRes, gathered at an exponential rate\n over 3 years. That’s a lot. We didn’t yet have good common standards\n (Jeremy Brown started one, later edited by\n Dan Weinreb; I\n recently took it over, expanded it, merged it into the existing\n beginning of a Google Common Lisp Style Guide and published it), and\n it was sometimes hard to follow what another hacker wrote,\n particularly if the author was a recently hired\n three-comma programmer. But\n with or without standards, our real, major, problem was with lack of\n appropriate management.
\n\n
We were too many hackers to run without management, and none of our\n main programmers were interested in becoming managers; instead\n managers were parachuted from above, and some of them were pretty\n bad: the worst amongst them immediately behaved like empire-building\n bullies. These bad managers were trying to control us with\n impossibly short, arbitrary deadlines; not only did it cause overall\n bad quality code and morale burnout, the renewing of such deadlines\n quarter after quarter was an impediment to any long-term\n architectural consideration for years. What is even worse, the\n organization as setup had a lot of inherent bad incentives and\n created a lot of conflicts, so that even passable managers would\n create damage, and otherwise good engineers were pitted against each\n other on two sides of absurd interfaces, each team developing a lot\n of scar tissue around these interfaces to isolate itself from the\n other teams. Finally, I could witness how disruptive a single bad\n apple can be when empowered by bad management rather than promptly\n fired.
\n\n
I have had a lot of losing fights with QRes management at a time\n when, hanging on a H1B visa, I was too much of a coward to\n quit. Eventually, the bad people left, one by one, leaving behind a\n dysfunctional organization; and great as the people that manned it\n may have been, none was able or willing to fix the\n organization. Then finally, Google acquired us. There’s a reason\n why, of two companies founded at about the same time, one buys the\n other and not the other way around: one grew faster because it got\n some essential things right that the other didn’t. Google, imperfect\n as it necessarily is, gets those essential things right. It cares\n about the long term. It builds things to scale. It has a sensible\n organization. It has a bottom up culture. So far, things have only\n improved within QRes. Also, launching was also good in many ways. It\n makes us and keeps us real.
\n\n
Lisp can be something of a magic tool to solve the hardest technical\n issues; unhappily it doesn’t even start to address the social\n issues. We wasted a whole lot of talent due to these social issues,\n and I believe that in an indirect way, this is related to the lack\n of modularity in Common Lisp, as it fostered a culture of loners\n unprepared to take on these social issues.
\n\n
So I’m not telling you this story just to vent my past\n frustration. There too I have a cybernetic message to pass on:\n incentives matter, and technical infrastructure as well as social\n institutions shape those incentives and are shaped by them.
\n\n
As for the future of Lisp at Google, that million line of Common\n Lisp code ain’t gonna rewrite itself into C++, Java, Python, Go, or\n even DART. I don’t think the obvious suggestions that we should\n rewrite it were ever taken seriously. It probably wouldn’t help with\n turnover either. But maybe, if it keeps growing large enough, that\n pile of code will eventually achieve sentience and rewrite itself\n indeed. Either that, or it will commit suicide upon realizing the\n horror.
\n

\n\n

Anything else I forgot to ask?

\n\n

\n
Ponies.
\n

\n\n

\n $\"Faré\"$

Faré

\n\n

2012-10-19

\n\n

Daniel Barlow (UK)

\n\n

Daniel Barlow was one of the most active contributors to the open\nsource Lisp ecosystem, when its development took off in the early\n2000s. Together with Christophe Rhodes he was the first to join SBCL\nhacking, after the project was started by\nWilliam Newman. He also had\ncreated a lot of early Lisp web tools, like\nAraneida HTTP application server, and\nbuilt on it the first version of cliki.net which\nserved the Lisp community for almost 10 years (the second version went\nlive earlier in 2012). Studying Cliki source was a kind of zen\nexperience for me, as it did so much, yet in a very simple way.

\n\n

But his largest contribution is, probably,\nASDF, regarding which,\nlikewise Cliki, there are controversial opinions among Lisp\nprogrammers. And Dan explains his attitude in the interview.

\n\n

In the mid 2000s his involvement with open-source Lisp gradually\ndiminished, as he stopped working as a consultant and got a full-time\njob. Yet he remains fondly remembered in the community.

\n\n

Tell us something interesting about yourself.

\n\n

\n
I don’t do interesting. Um, improvise. Hacker, skater, cyclist,\n husband, father to a seven-month-old son as demanding as he is\n adorable, computing retro-grouch who uses Linux on the desktop.
\n\n
I have a metal plate and some pins in my right forearm where I broke\n it a couple of months ago, inline skating in the Le Mans 24 hour\n relay event. I have now regained more or less complete range of\n motion in that hand and can advise anyone doing the event next year\n that the carpet in the pit boxes is unexpectedly treacherous when\n it’s been waterlogged by a sudden thunderstorm.
\n\n
Still, we came fifth in category, which makes me very happy.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I started a new job about three months ago, in fact. I’m now working\n at Simply Business in London, busily disrupting the business\n insurance market. Which is to say, writing web apps for the online\n sale of business insurance.
\n\n
It’s not quite as buzzwordy as it sounds, actually. Business\n insurance is traditionally sold by brokers, who are humans and\n therefore although really good at dealing with complex cases and\n large contracts where the personal touch is required, tend to be a\n trifle expensive for straightforward policies which could be much\n more economically sold online. The industy is ripe for disintermediation.
\n

\n\n

What brought you to Lisp?

\n\n

\n
A combination of factors around the time I was at university:\n the UNIX-Haters Handbook,\n which I bought to sneer at and ended up agreeing with; Caml Light,\n which I used in my fourth year project; Perl - specifically my\n horror to learn that it flattens (1,2,3,(4,5,6)) to\n (1,2,3,4,5,6) - yes, I know about references, but I think it’s a\n bug not a feature that the sensible syntax is reserved for the silly\n behaviour - and meeting some people from Harlequin (as was) at a\n careers fair.
\n\n
It took me another couple of years or so to find CMUCL - in fact, I\n think it was another couple of years or so before it was ported to\n the x86 architecture, so it wouldn’t have done me much good if I had\n known about it earlier - but looking back I suppose that was where\n the rot set in.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
No, we’re primarily a Ruby shop, with a sideline in large legacy\n Java app which we’re working to replace. I think there’ve been a\n couple of uses of Clojure in hack days, but that’s as far as it\n goes.
\n\n
Why not? Well, apart from the point that I’ve only been there since\n July… It’s The Ecosystem, I suppose. Ruby as a language has\n pretty good support for OO paradigms and a whole bunch of free\n software libraries for doing web-related things: Ruby as a community\n is big on Agile and TDD and maintainable design. And it’s at least\n possible (if not exactly easy in the current bubble) to engage a\n regular recruitment agent and task him with finding competent\n programmers who know it. I’m not saying Lisp is exactly bad at any\n of that, but it’s at least questionable whether it’s as good along\n all of those axes, and it’s certainly not better enough to make the\n switch sensible.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
SBCL was probably one of the most fun projects I’ve ever worked on.\n Working with people who were mostly smarter than me or had\n better taste than me or both, on a project whose goal was to make it\n possible for people less smart than me to hack on a Lisp system. And\n context switching between the CL with all its high level features\n and (e.g.) Alpha assembly was a real kick - it’s a bit like I\n imagine building a Lisp machine would be, except that the goal is\n achievable and the result is generally useful.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
I don’t really use it enough any more to react to that with the\n required levels of venom. I should probably say ASDF, everyone else\n does :-)
\n\n
I guess if you force me to an answer, it’d have to be its disdain\n for the platform it lives on - take, for example, CL pathname case\n conversion rules. Whoever decided that Unix systems could reasonably\n be said to have a “customary case” had, in my view, not looked very\n hard at it.
\n

\n\n

As far as I can tell, you’re currently mostly doing work in Ruby. What’s the pros and cons of Ruby development compared to Lisp?

\n\n

\n
The transpose-sexps function in Emacs does nothing useful in Ruby\n mode. rails console is a poor substitute for a proper\n toplevel. Backtraces don’t show the values of parameters and local\n variables. (Yes, pry helps a lot). And the garbage collector (in\n MRI, anyway) is sucky to the point that even 1990s Java GC could\n probably beat it in a fair fight.
\n\n
On the other hand, libraries.
\n\n
Here’s an interesting thought experiment, though: there’s a clear\n difference between the Lisp workflow where you change the state of\n your image interactively to get the code into working shape very\n quickly (and then later try to remember what it was you did) and the\n more scripted approach of test-driven development in Ruby where you\n put everything (code, test setup, assertions) in files that you\n reload from disk on each run. How would you meld the two to get\n repeatable and fast iterations? A lot of people are doing things\n like Spork (which forks your application for each test it runs,\n throwing the child state away after the test has run) but they never\n seem to me to be more than 80% solutions. My intuition is that you’d\n want to stick to a much more functional design and just make state a\n non-problem.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
SBCL was a lot of fun, as I said earlier. ASDF is a candidate too,\n just because it must so obviously fill a need if people are still\n cursing it - as they seem to be - ten years later :-)
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
It’s taken me the best part of three months to get this interview\n back, I’m the last person anyone should be asking about\n workflow or productivity. :-)
\n\n
Um. I’ve been doing a lot of TDD lately. Given that as recently as\n two years ago I was castigating it as a religion this might be seen\n as a capitulation or as a conversion, this might be perceived as a\n change of mind. What can I say? Actually, pretty much now what I\n said then: the value of TDD is in the forces it exerts on your\n design — towards modularity, functional purity, decoupling, all\n those good things — not so much in the actual test suite you end up\n with. Process not product. These days everyone thinks that’s\n obvious, but back then it was either less widely known or less\n explicitly stated or else I was just reading the wrong blogs.
\n\n
(Of course, the tendency in Lisp to write code interactively that\n can be tested ad hoc at the repl probably has a very similar effect\n on coupling and functional style. My personal experience is that TDD\n doesn’t seem to be nearly as valuable in repl-oriented languages,\n but YMMV.)
\n\n
More generally: go home, do some exercise, get some sleep. Sleep is\n way underrated.
\n

\n\n

Anything else I forgot to ask?

\n\n

\n
Some day I will write an apology for ASDF.
\n\n
Pedants will note that the word “apology” not only means “an\n expression of remorse or regret” but also “a formal justification or\n defence”, and may infer from that and my general unwillingness to\n ever admit I was wrong that I’m not about to actually say I did a\n bad thing in writing it. Seriously, go find a copy of MK-DEFSYSTEM\n and try porting it to a Lisp implementation it doesn’t support.
\n\n
In 2002 I presented a paper at the ILC (about CLiki, not ASDF) that\n said essentially “worse is better than nothing”, and — unless the\n “worse” has the effect of stifling a potential better solution from\n coming along later — I still stand by that.
\n

\n\n

\n $\"danb\"$

danb

\n\n

2012-10-08

\n\n

Christophe Rhodes (UK)

\n\n

Christophe Rhodes is the SBCL’s principal maintainer. He was among the\nfirst two people to join the project, after it was solely developed\nfor more than a year by\nWilliam Newman. And he is,\nprobably, the most “stable” contributor, still remaining very active\nin the community, after more than a decade. What fascinates me\npersonally about him, is the aura of a profoundly creative mind,\nfiddling with reality in interesting and unexpected ways.

\n\n

His twitter is @ascii19

\n\n

Tell us something interesting about yourself.

\n\n

\n
I’m a singer, specializing in performance (admittedly somewhat rare\n at the moment) of unaccompanied music of the European\n Renaissance. My next concert is Brumel’s “Earthquake Mass” with the\n vocal ensemble De Profundis. I did\n my doctoral research a few doors down from Stephen Hawking. And I\n was a cast member on “Una Stravaganza dei Medici”, a reconstruction\n of the Florentine festivities for the marriage of Ferdinand de\n Medici and Christine of Lorraine - which means that there’s at least\n some chance I have an Erdős-Bacon number.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
Oh, well, that’s a bit complicated! :-) Most of my time at the\n moment is spent with Teclo Networks, a\n Lisp-flavoured startup which is bringing reliability and usability\n to mobile broadband. I’m on leave of absence to pursue this from\n Goldsmiths, University of London,\n where I am a lecturer in Computing, responsible for undergraduate\n teaching, postgraduate supervision and independent research.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
I do. I should say that I’m no longer, if I ever was, a programmer\n by trade; most of my work at Teclo is not writing code, but when I\n do it is in C, R or Common Lisp. Working in a Lisp-flavoured startup\n (I’m not the most famous Lisp programmer in the company, and quite\n some way from being the best…) has made Lisp a natural tool to use\n when it’s appropriate; while it might be a bit of a shame that Lisp\n is not used exclusively, the balance of idealism and pragmatism is\n pretty good, and it’s fairly satisfying to know that the\n high-performance network element that we ship has Lisp code\n controlling its operation.
\n\n
I wouldn’t make an argument that C is a Lisp by any stretch, but\n I’ve popped up at a couple of events in the last year to argue that\n R has some claims to being a Lisp; it has conditions, handlers,\n restarts, generic functions, macros operating on parse trees… and\n a SWANK backend.
\n\n
Another part of what I do is write documents, both for Teclo and for\n Goldsmiths. I have in the last couple of years fallen in love with\n org-mode and in particular with “reproducible\n research”, or living documents; the ability to have executable\n sections of code for generating results, which can then themselves\n be further analysed by other bits of code — in other languages, if\n that’s appropriate — and the whole exported as a document typeset to\n what I consider to be high-quality standards. The fact that there is\n also acceptable-quality web output from the exact same process is\n gravy.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
Two seminal moments on my road to Lisp: the first was, as an\n undergraduate, getting a job in the summer of 1997 to work on\n simulating fluid dynamics in the context of galaxy formation, to\n assist in trying to understand how the spiral arm structures form.\n I’d being told “here is K&R, here is USENET, here is XEmacs,\n here is Tcl; in five weeks let’s see what you’ve come up with” —\n I distinctly remember reading comp.lang.lisp and a “Lisp is slow”\n thread, with active participants combating the troll with\n disassembly.
\n\n
The second, a few years later, was wandering into the #lisp IRC\n channel on openprojects, to find an almost-empty channel, about\n 10-20 participants; one of whom was there twice (dan_b and dan`b),\n using the channel to paste bits of alpha assembly between his laptop\n and his desktop, in his efforts to get SBCL on alpha working.
\n\n
As for what keeps me, well, when what I have to do is solve problems\n that no language has built-in libraries for (scalable audio\n similarity detection, say, or musical structure inference) then I\n want to be working in a language where I can focus on the problem\n itself, rather than the detail of that language — and for me, Lisp\n permits that kind of separation of concerns, given its easy support\n for DSL and embedded language generation, protocols, and the ability\n to run partial programs.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
I enjoyed most working on\n an editor for lute tablature,\n I think. Partly because it was a chance to learn about things\n (parsing, CLIM, user interfaces) that I hadn’t really thought about\n before. Partly because of the feeling of being able to build up\n incrementally and rapidly from a very simple prototype to deliver\n something which was actually useful; and partly because it was also\n interesting to learn about the problem domain. Gsharp (G#), the\n score editor largely designed by Robert Strandh, is an editor for\n what you might call “common practice” notation: five lines in a\n staff; dots and lines to indicate pitch (by height) and duration (by\n glyph) of notes. In my research group at Goldsmiths, though, we have\n a lutenist (a player of the lute) who had a research project on\n cataloguing and transcribing a particular repertoire of 16th-century\n lute music, which was notated in “tablature”: six lines, one per\n string of the lute; letter or number glyphs on each line to indicate\n finger position; and glyphs above the staff to indicate duration.
\n\n
The point about this was that when I first came on the scene the\n project had a truly awful workflow, because they had a batch\n renderer from the textual format to encode this music to something\n visual. This made the process of encoding painful, in particular for\n the error correction phase: it was fairly easy to find an error in\n the visual rendering, but to go from there to the text corresponding\n to it was painful. So I wrote a little CLIM app with an editor\n buffer and a display; the display was a rendering of the “Tabcode”\n in the editor buffer, and each glyph in it was associated with a\n text cursor position, so that you could click on the display and\n have the editor cursor warp to the Tabcode corresponding to the\n glyph. This was a productivity win for the project.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
I don’t get easily excited by technology. So for me, what was\n exciting was seeing a community of users and developers grow around\n SBCL — in particular, working with extremely focused and motivated\n individuals on improving the system, subject to all sorts of\n constraints, not least those imposed by real-world uses (including\n the\n QPX\n poster-child of ITA Software).
\n

\n\n\n\n

\n
I think part of SBCL’s success as a community was the finding of\n like minds — which came about partly because it started off as a\n project when access to information channels was growing, but also\n partly because there were some explicit principles laid down: Bill\n Newman made it very clear that he was aiming for something\n maintainable, and also taught by example the meaning of\n maintainability. In the SBCL source distribution, there are over 100\n lines of textual detail describing his ideas about what he was\n aiming for, and although it’s nothing like an explicit charter which\n every SBCL developer (or user!) has to sign up to, it’s nevertheless\n a useful indication of a direction to drive in. Both detailed and\n motivated enough that even a graduate student with no software\n development experience could understand that there were tradeoffs\n involved, and someone had thought hard about which side of the\n tradeoffs they wanted to be. I’d also point out some of Bill’s\n advodiary entries of the time, including\n http://www.advogato.org/person/wnewman/diary/6.html and\n http://www.advogato.org/person/wnewman/diary/9.html, which perhaps\n illustrate that he was thinking about this kind of software\n maintenance all the time. (“To foil the maintenance programmer…”\n :-)
\n\n
I think this is particularly important when the bulk of the work is\n done by volunteers; it helps to keep focus (I’ve written before\n about how software is only sustainable if it can stay alive in the\n minds of its developers).
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
There’s lots that I’d like to do, both hacking on Lisp itself and\n things I’d like to explore, for which I’m likely to reach for Lisp\n first. I’d also like to get more fluent with emacs lisp, enough to\n be able to quickly write the user interfaces I would like to use to\n various bits of software that I use every day.
\n

\n\n

\n $\"Christophe\"$

Christophe

\n\n

2012-03-26

\n\n

Luke Gorrie (Australia - Sweeden - Switzerland)

\n\n

Luke Gorrie is a proverbial hacker following his passion for\nprogramming to various places in the physical world, like Sweden or\nNepal, or programming world, like Erlang, Forth, Lisp, Lua, or some\nother fringe language. And enjoying the process of exploration and\nmeeting different people, while fiddling with computers, from OLPC to\ntelecom equipment, working with world-famous technologists, including\nJoe Armstrong or Alan Kay, and, generally, doing whatever he likes in\nthe programming world.

\n\n

He was one of the main authors of\nSLIME in its early days. And\nrecently he founded a Lisp networking startup Teclo Networks, the\nstory of which (as of fall of 2011) he\ntold at ECLM 2011.

\n\n

His twitter account is @lukego

\n\n

Tell us something interesting about yourself.

\n\n

\n
I enjoy exploring the world. I was born and raised in Australia\n (Brisbane), I’ve lived for many years in Sweden and become a Swedish\n citizen, and these days I’m extremely happy to be settling myself\n into Switzerland. I’ve spent a couple of years traveling\n continuously with just my backpack and unicycle and no home anywhere\n to go back to. I’ve found this interesting. You can find links to my\n exploits on my homepage.
\n\n
I like to feel a bit out of my depth and to be “the new guy” who has\n a lot of catching up to do. This is why I so much enjoy learning new\n programming languages and visiting new programming communities so\n much: the feeling of having to think really hard about how to\n formulate even the most basic programs, just like when I was a kid,\n while other people do it so naturally.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I’m currently starting a new project called\n Snabb. It’s too early to say very much about\n this yet, so I’ll talk about the past.
\n\n
I’ve had a few major jobs that have shaped my thinking. I worked in\n each one for about 3-5 years.
\n\n
The first was Bluetail AB, the first Erlang startup company. I was\n hired by Joe Armstrong because I had\n enthusiasm pouring out of my ears and nostrils. I moved immediately\n to Stockholm in the middle of winter for this job — I was 21 years\n old and I’d never left Australia or seen snow before. I learned a\n lot of things at\n Bluetail,\n besides practical matters like how to walk on ice. The programmers\n there were all way above my level and I was routinely stunned at the\n stuff they had done, like when Tobbe Törnqvist mentioned in passing\n that he’d written his own TCP/IP stack from scratch as a hobby\n project and that his dial-up internet connection uses his own\n home-brew PPP implementation. I used to roam the corridors at night\n borrowing tech books from people’s shelves, there must have been a\n thousand books in the office.
\n\n
Bluetail was\n bought by Alteon,\n who were bought by Nortel at the same time, and become a productive\n little product unit in a big networking company.
\n\n
Next was Synapse Mobile Networks. This was\n an amazing experience for me: to switch from a big company to a\n small company and take care of everything from design to development\n to deployment to support by ourselves. Really getting to know\n customers and internalizing their needs and building the right\n solutions. The product is a device management system, which is a\n realtime database in a mobile phone network keeping track of which\n phone everybody is using and making sure all their services\n work. The whole thing was written in Erlang and BerkeleyDB, even\n with a from-scratch SS7 telecom networking stack in the end. I would\n routinely fly to a really interesting country — Kazakhstan, Jordan,\n Russia, Algeria, you name it — and spend a few weeks deploying the\n system and developing customizations on-site. Synapse was the first\n company in this market and they are still the market leader\n today. The system has by now configured approximately 1 billion\n actual mobile phones by sending them coded SMSes.
\n\n
Synapse was also instructive in seeing how much a strong personality\n can shapee a company. I’m still in awe of our fearless leader Per\n Bergqvist. What a guy, as they say on Red Dwarf.
\n\n
The most recent is Teclo Networks. This is\n a company that I co-founded with friends from the SBCL community —\n mostly drinking buddies from ECLM — and friends from the telecom\n world. I served as CTO during the phase of finding the right problem\n to solve, building our series of prototypes and our real product,\n and finding our very first customers. I’m a Teclo-alumnus now, not\n actively working in the company, and: Wow, this was a really intense\n few years.
\n\n
Teclo builds network appliances that optimize TCP traffic for\n cellular internet at about 20Gbps per server. The product speeds up\n the network, improves consistency, and globally eliminates\n buffer-bloat. The company is currently moving forward with a lot of\n momentum: we have Lispers like\n Juho Snellman,\n Tobias Rittweiler, and Ties\n Stuij currently deploying systems in real live networks all over the\n world. Go Teclo :-)
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
I’ve mostly done Lisp hacking for my own pleasure on the side,\n but I’ve also used it quite a bit at work.
\n\n
The first time was when I used Scheme at Bluetail. Specifically, I\n used Kawa to extend a Java application. I’m sure this raised some\n eyebrows amongst my colleagues but frankly I was having too much fun\n to really notice. Kawa is a great piece of software.
\n\n
I wrote a bunch of Common Lisp networking code while reading books\n like TCP/IP Illustrated. This was a hobby project called\n Slitch and Netkit. I used\n this slightly in my work at Nortel to replicate a DoS against the\n Linux kernel that was crashing some of our appliances.
\n\n
Teclo is very much a Lisp-hacker shop. In the first year or so we\n used Lisp for absolutely everything. We’ve written and deployed a\n prototype TCP/IP implementation written in Common Lisp (SBCL), wrote\n network analysis tools for cross-referencing and visualizing traffic\n captures (often working on traces that fill up a whole disk\n i.e. hundreds of gigabytes), and developed all of the\n operation-and-maintenance infrastructure in CL. These days Teclo\n uses C/C++ for the main traffic handling, R for statistical\n analysis, and Common Lisp for the rest — mostly operation and\n maintenance and data visualization.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
SLIME! This was wild fun. The project started when Eric Marsden, a\n CMUCL hacker, posted to #lisp his weekend hack to annotate\n individual S-expressions in an Emacs buffer with CMUCL compiler\n messages. His source files were slim.el and skank.lisp, after\n the Fatboy Slim song he was listening to at the time. I loved the\n idea so I started toying with it, renaming the files to slime.el\n and swank.lisp to make them easy to diff. I quickly posted my\n version to the cmucl-dev mailing list where\n Helmut Eller jumped right into it\n too. We created a Sourceforge project and quickly snowballed from\n there to over 100 contributors.
\n\n
SLIME’s mission was ultimately to replace ILISP as the standard\n Emacs mode for interacting with Common Lisp. ILISP worked by sending\n S-expressions between Emacs and Lisp via standard I/O and it had the\n unfortunate habit of getting stuck a lot. ILISP was also about 15\n years old at that time (SLIME is catching up now at 8 years!) and\n really hard to work on due to the heavy use of reader conditionals\n in the source code, like #+cmucl #-lucid #+sbcl #-lispworks #+acl\n #-acl4.2 and so on.
\n\n
I really enjoyed the feeling of working on a growing and thriving\n open-source project. Seeing the steady stream of new names appearing\n on our mailing list, getting patches from dozens of people, feeling\n good about positive feedback we received, working hard on negative\n feedback right away, and so on. Twas a really productive flow.
\n\n
I think that writing development tools is also really satisfying\n because your users are your peer group: people you really look up to\n and respect and sometimes drink beer with. It’s a great feeling to\n build stuff that they like to use.
\n\n
Helmut Eller and I also had a really great working style. Very often\n I’d do some late-night hacking and check in a bunch of new\n functionality, which Helmut would then read through and think about\n and then thoughtfully rewrite in a simpler way. Then I’d see what\n he’d done, think about it, and rewrite it to be simpler again. And\n so on. This was a really pleasant and productive way of working. He\n is also an absolute magician when it comes to suddenly checking in\n what seems like a month worth of work that he did over the\n weekend. (Juho Snellman has this uncanny ability too.)
\n\n
I hacked on SLIME from the beginning and up to version 1.0. Then I\n was engulfed by an Erlang startup. Here’re some posts that I fished\n out of the mailing list archives to give a sense of the early days:
\n\n
\n
SLIME is born
\n
Users!
\n
SLIME User Survey
\n
SLIME 1.0 release party :-)
\n
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
My friend Darius Bacon brought me to Lisp (Scheme) by gently and\n persistently singing the praises of Abelson & Sussman back in the\n days when I was a teenager hacking Java. This book was a revelation\n for me: particularly the Digital Circuit Simulator. So I was a\n Scheme-lover for several years, but Darius also gently and\n persistently sang the praises of Norvig’s\n Paradigms of AI Programming, which\n was another revelation to me, and made a Common Lisp convert of me.
\n\n
What holds me to Lisp is the people. I love hanging out with Lisp\n hackers: I find that we’re an unusually diverse community. How often\n do you attend a small conference where attendees are building\n nuclear defense systems, running intensive care wards, designing\n aeroplane engines, analysing Lute tablature, developing cancer\n drugs, writing FIFA’s legal contracts, and designing their own\n microchips? Surely this describes few tech events other than Arthur\n & Edi’s European Common Lisp Meeting :-).
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
I have a few stock rants that I’m tempted to rattle off —\n fragmentation, threads, GC-phobia — but honestly I doubt they are\n applicable these days. There have been so many improvements to SBCL\n and great developments like Quicklisp and so on.
\n\n
I can say I’m personally disappointed about the missed opportunity\n for us to write Teclo’s production traffic path in SBCL. Ultimately,\n the software has just a few microseconds’ budget to process each\n packet, and can never spike latency by more than a millisecond. I\n don’t know how to deliver that kind of performance in a high-level\n language like Lisp. So we fell back to C.
\n\n
I’d also like to have embedded SBCL in the C program to take care of\n high-level work like slurping in configurations and spitting out\n statistics. But the SBCL runtime system is a bit heavyweight to make\n that practical. It gets in the way when you want to debug with\n strace, gdb, etc. So we wrote this stuff in C++ instead.
\n\n
I’d have written a lot more Lisp code in recent years if I’d found\n good solutions to those problems. But at the end of the day it is\n C’s niche to write lots of tiny state machines with extremely\n predictable performance characteristics, so I’m not especially\n shocked or disheartened. A language can’t occupy every niche at once :-)
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers

\n\n

\n
I’m an incrementalist. I like to start from minimal running code,\n like (defun program () (print \"Program 0.1\")), and move forward in a\n long series of very small steps. I tend to choose designs that I\n know are too simple or too slow, because I enjoy the feeling of\n hitting their limits and knowing that I didn’t prematurely\n generalize or optimize them. Then I fix them. I’d say that I’m much\n influenced by watching the development of Extreme Programming on\n WardsWiki in the 90s.
\n\n
This isn’t a hard and fast rule though. In Teclo I once spent a\n whole month writing a complex program without even trying to compile\n it once. This was a rewrite of the main traffic engine in C after\n having written a prototype in Lisp previously. This was a really fun\n way to work actually. I produced a tremendous amount of bugs in this\n style though and I wasn’t smart enough to fix them. Christophe\n Rhodes did that part — don’t ask me how :-).
\n\n
I do have a tip for getting into “the flow”. It’s a simple one: make\n a little TODO list of some features you want to hack, and take the\n laptop into the park away from the internet for an hour or two until\n they’re done. This works every time for me.
\n\n
Oh, and I highly recommend printing out and reading your\n programs. This is the best way that I know for improving their\n quality. This is why I’m a bit picky about things like the 80-column\n rule and the layout of functions within a file. I want to be able to\n print programs out and read them on paper from top to bottom. I\n wrote a program called pbook to help with this — it’s not a very\n good implementation though, with all those regexps, so I’d love if\n someone would make a much simpler one.
\n

\n\n

You have played around with so many languages, like Erlang, Lisp, Smalltalk & LuaJit. If you would design your own, how would it look like?

\n\n

\n
That’s really hard to imagine. I’d have to find a reason that I\n needed a new programming language, and the details would probably\n follow from the problem I needed to solve.
\n\n
I learn new languages mostly because I enjoy meeting new people and\n learning new ways of thinking. It’s very seldom from any sense of\n dissatisfaction with previous languages I’ve used. My favourite\n languages are Common Lisp, Emacs Lisp, Forth, Erlang, Smalltalk, and C.\n So the best I can say is: those are the languages that I’d like\n to have designed.
\n

\n\n

\n $\"Luke\"$

Luke

\n\n

2012-07-25

\n\n

Juan José García Ripoll (Spain)

\n\n

Juan José García Ripoll is a physicist and the principal developer of\nEmbeddable Common Lisp (ECL), an\nimplementation that compiles to C instead of native code and provides\na shared library, so that Lisp programs can be distributed without the\nLisp runtime and be embedded in other programs. He also actively\ncontributes to the improvement of ASDF, the foundational system\ndefinition facility (one of his posts on the\ntopic).

\n\n

Juanjo is a representative of a large group of Lisp users —\nresearchers and scientists, who are not professional\nprogrammers. Although Lisp is not generally considered alongside\nspecialized research environments, like Matlab or R, it is quite\nuseful in this field because of its solid mathematical foundation,\ncoupled with truly interactive and robust environment.

\n\n

Tell us something interesting about yourself.

\n\n

\n
I do not consider myself to be an interesting character or have\n interesting hobbies, but my job is quite interesting and\n unconventional: I work on Quantum Computation, developing new ways\n of computing using, for instance,\n superconducting circuits,\n or\n arrays of atoms. Actually\n I find that the fact that human technology has progressed to the\n point that we can\n trap and harness individual atoms\n is pretty cool.
\n

\n\n

What’s your job? Tell us about your organization.

\n\n

\n
I am a physicist and work as a scientist for\n CSIC, the Spanish Research Council. It is the\n largest research institution in Spain and my group works on all kind\n of exotic things related to the implementation of quantum computers.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
From my description above it might seem that it would be hard to use\n Lisp for anything, but quite the contrary: 50% of our time is spent\n doing simulations and programming. Quite interestingly, the programs\n that we develop are very short-lived. We have a question, write a\n simulation, get the data, move on. This is the reason why most\n people in our field use Matlab. I reached Lisp looking for an\n interactive programming language that was more powerful than Matlab\n in the fields of expressiveness, extensibility, optimization. That\n is how I started working on ECL, with the aim of empowering it for\n numerical simulations. Along the way I got distracted and more\n interested in the fields of language development.
\n\n
Despite this I have found room for Lisp in my daily routine, from\n scripting all the way up to solving actual problems. For instance,\n in one of our research topics we had to solve huge instances of\n 3-SAT problems using a very basic algorithm. The fact that Common\n Lisp comes with bignums reduced the development time to one\n afternoon and the program we produced was faster than the C++\n prototypes we had.
\n

\n\n

Among software projects you’ve participated in what’s your favorite?

\n\n

\n
My favorite is ECL, but my second favorite was developing for an\n extinct operating system, OS/2. Back when I was at the university,\n OS/2 was still alive and I got some interesting projects finished,\n such as an X-Windows server and the port of Doom to it. It was\n pretty cool to learn multithreading and GUI development back then\n and OS/2 was pretty well thought out.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
My job brought me to it, and what keeps me is the possibility of\n learning a lot about language implementations, compilers and making\n a tool that is useful for a larger community, including other\n projects such as Sage. It is a weak link\n though, and sometimes personal interactions make me question whether\n this is useful at all.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
ECL. Really. After one year of development it was awesome to see ECL\n being able to build and compile itself from scratch for the first\n time. Also, every time I finish yet another feature, it feels really\n good. And finally, developing a Common Lisp implementation is a\n great excuse to learn a lot of things, from the subtleties of the\n POSIX specification, to the Unicode collation algorithms.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
The unspecified corners. Multithreading was not in the specification\n and implementations have evolved in somewhat random ways, with some\n common denominator and features (process-kill) which are not really\n well suited for existing operating systems and are nightmare to\n implement. I also miss a better specification of physical pathnames.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
Sorry, I am a terribly disorganized developer and ECL users suffer\n from it. No advice here, hehe.
\n

\n\n

You are a physicist by main occupation, yet you manage to almost single-handedly support ECL. Why? and How?

\n\n

\n
Everybody needs some projects in life other than work and this one\n is a lifelong companion that I would like to see to the end. I had a\n lot of help from freelance programmers at the beginning and users\n cooperate with patches and bug reports, and a lot of patience for my\n mistakes and absences. That helps.
\n\n
That does not mean I consider the current status an optimal one. I\n consider it a personal failure the fact that ECL does not have a\n larger community and a better support base. It still persists the\n wrong impression that ECL is a lesser implementation, covering a\n niche (embeddability) and inferior to other implementations which\n are more lispy in nature. That is not the case: we have sufficiently\n proven that the underlying core, C, does not prevent any feature\n from being implemented, performance is improving and stability,\n well, this is not always optimal, but it has to be blamed to the\n small size of the developer team, which has scarce resources for\n testing the code.
\n

\n\n

\n $\"Juanjo\"$

Juanjo

\n\n

2012-06-25

\n\n

John Fremlin (USA)

\n\n

John Fremlin has created a couple of very performant Common Lisp\nprograms beating on some microbenchmarks the fastest similar software\nwritten in any other language, including C: the\nteepeedee2 dynamic webserver,\nthat managed to break the c10k record on a single core machine, and\ncl-irregsexp regex\nlibrary. Working at MSI in Japan\nhe also had written an object persistence DB for CL called\nmanardb. Besides,\nhe writes interesting blogs on topics of\nsoftware optimization, programming languages and technology in\ngeneral.

\n\n

Tell us something interesting about yourself.

\n\n

\n
I’ve been to more than eighty countries; I want to go everywhere!
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I work at Facebook on the growth team, on data-driven improvements\n to the sign-up flows.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
I used to at msi.co.jp. It is a Japanese consultancy based in Tokyo\n called originally Mathematical Systems Institute. Mr Kuroda leads\n the Lisp group there and I think it has hovered around five or six\n people over many years. He’s done a great many very interesting\n projects for a range of companies over the years: for example a\n crash-test data inspection tool for a big Japanese car company, text\n mining, graph visualisation and so on. I worked primarily on\n building up a visualisation and mapping of a very large set of\n routers for the world’s biggest telecoms, which led to the creation\n of manardb.
\n\n
I really enjoyed working for Mr Kuroda and I’m sorry I had to leave\n for personal reasons. There were always many very fascinating\n problems around â€” with great people to discuss them and find\n solutions. It was a very stimulating workplace! At Facebook, I use\n PHP, Python, C++, Java and miscellaneous things. I think we would\n all be better off if we hadn’t balkanised the different systems that\n we program for â€” and Lisp is one of the few programming languages\n with the flexibility to serve in all these roles.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
My initial programming was following Michael Abrash’s graphics books\n and building on his ideas, by doing things like runtime native code\n generation for drawing dynamically generated bitmaps\n efficiently. This is not so interesting for modern processors as\n they have good branch prediction but the idea of code generation\n stuck with me and Lisp is one of the few programing languages that\n makes this easy and efficient.
\n\n
I appreciate the intellectual coherence of Lisp, and its sensible\n approach to numeric computations. In terms of using it today, I feel\n that Common Lisp has an advantage over many other programming\n languages in that it has multiple mature independent\n implementations. Running on multiple compilers tends to greatly\n increase the quality of a program in my opinion, as the code is\n exposed to different static analysis.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
I helped someone use Lisp for an automated trading project.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
In trying to make efficient code one ends up fighting against the\n compiler and the runtime system and most of the time is spent in\n coming up with clever ways to circumvent and outwit both. This is\n not a good use of resources, and means that it usually makes more\n sense to start with C++.
\n

\n\n

Tell us about your approach(es) to optimizing Common Lisp code (and maybe code optimization in general)?

\n\n

\n
The most important thing is to try to hold in your head an\n understanding of where the program is going to spend time. Profilers\n can be misleading and inaccurate, and it is sometimes difficult to\n get representative workloads to profile. I think their main utility\n is in confirming that there is no sloppy mistake (in Lisp,\n typically, consing accidentally) that prevents you from achieving\n the natural performance of your approach.
\n\n
Complexity analysis in terms of computation, network usage, disk\n accesses and memory accesses is a first step as obviously if you can\n improve the asymptotic usage of a bottlenecked resource, you will\n very likely do much better than trying to tweak some little\n detail. The second step is to try to characterize interactions with\n caches and, in Lisp, garbage collection, which is pretty tricky.
\n

\n\n

Among the software projects you’ve participated in what’s your favorite?

\n\n

\n
I think the one I enjoyed most was an embedded H.264 decoder in 2005.\n This was for the VideoCore, a really wonderful CPU\n architecture that could deal with parallelizable problems incredibly\n efficiently if programmed correctly. It would have been awesome to\n use Lisp for it!
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
I wish there were Lisp bridges to other runtime systems (Java,\n Android, Objective C, Perl, Python, C++, R, etc.) so that the\n libraries and tools for each could be leveraged efficiently in Lisp\n and vice versa. That would mean being able to call Java code and\n handle Java objects in Lisp, for example â€” perhaps initially by\n spinning up a Java implementation in a separate process running a\n CL-SWANK style interface.
\n\n
I really don’t think this would be that difficult and it would make\n a huge difference to the convenience of building programs in Common\n Lisp!
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
I use emacs and I have a bunch of elisp code that I keep meaning to publish!
\n

\n\n

\n $\"John\"$

John

\n\n

2013-01-03

\n\n

Vladimir Sedach (Russia - Canada - USA)

\n\n

Vladimir Sedach is an active open-source Common Lisp developer and\nproponent, as well as a computing philosopher to some extent. At his\ncarcaddar blog he writes about\ndecentralized social networks, forgotten bits of computer history and,\nsurely, Lisp. He is the maintainer or originator of a few open-source\nlibraries like\nparenscript and\nEager-Future2, and works\non Vacietis C-to-Lisp compiler,\nwhich he describes in more detail in the interview.

\n\n

Together with Andrey Moskvitin they\nwere the driving force behind 2012 cliki update\neffort aka cliki2.

\n\n

His twitter is @vsedach

\n\n

Tell us something interesting about yourself.

\n\n

\n
In 2012 my best friend and I rode our bicycles across the USA.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
Right now I work at ZestFinance in Hollywood. We’re a relatively new\n company that’s helping the underbanked receive access to credit on\n more reasonable terms than otherwise obtainable, by using machine\n learning. The only thing bad about my job is that I get so focused\n on programming at work that I don’t have any desire to hack on Free\n Software projects when I come home, so a lot of my own projects are\n currently badly neglected.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
I’ve used Lisp for new commercial projects where people trust me\n with the technology choices. I’ve also come in to work on existing\n Lisp projects. I have used Lisp for one-off tasks at “non-Lisp”\n companies, but I’ve never started a Lisp project at a company that\n wasn’t using Lisp already. Most computer programmers tend to make\n technical decisions based on cliches they read about on the\n Internet, and unfortunately I don’t know the cure for being dumb.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
As a teenager I got interested in computer graphics, and came across\n this really cool 3d graphics program called Mirai from Nichimen\n Graphics. Mirai was written in Common Lisp, and I read more about\n Lisp in the\n Slashdot interview with Kent Pitman,\n and started reading SICP based on\n Kent’s recommendation. By the second chapter computer programming\n had finally made sense to me, and by the third I had decided to\n study mathematics in university.
\n\n
As an aside, Mirai is directly descended from the S-Graphics\n software from Symbolics. Not many people know this, but Symbolics\n was actually the second producer of commercially available 3d\n computer animation software (the first was Wavefront). S-Graphics\n was a complete modeling, animation, and painting system, and it was\n all written in Lisp in the mid 1980s.
\n\n
Common Lisp is still the best programming language I’ve come\n across. There is the feeling of freedom. No one is telling you what\n patterns or types to use. You can always just write code in a way\n that is most appropriate for what you’re currently doing.
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
Working with Daniel Gackle on Skysheet. We did some very awesome\n things with Parenscript.
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
No one has yet invented a good way to write “one-liners” in Lisp.\n I would love to replace my Unix shell with a Lisp REPL someday.
\n

\n\n

Among the software projects you’ve participated in what’s your favorite?

\n\n

\n
Vacietis, for the sheer amount of hacks per line of code, and for\n the “I proved them wrong” factor. It was during the development of\n Vacietis that I came up with my current programming philosophy:\n “when stuck, do the stupidest thing possible”
\n

\n\n

Tell us about Vacietis: your vision for it, the project’s progress and roadmap, what’s lacking?..

\n\n

\n
Vacietis was originally intended to be a translator for a subset of\n C code to Common Lisp. I discussed the idea for Vacietis a few times\n online before starting to code, and people generally thought it\n wouldn’t be doable.\n Scott Burson,\n who wrote the Zeta-C compiler for Lisp Machines in the 1980s, told\n me it would take at least a year of full-time of work.
\n\n
As I worked on Vacietis, I realized that adding more and more of the\n “advanced” C functionality was actually easy. First came the C\n preprocessor (which is implemented as part of the Common Lisp\n readtable that also parses the C code), then large patches of the C\n standard library, and then one day\n Brit Butler came along and sent\n me a one-page patch that actually used Vacietis as a stand-alone C\n compiler! I hadn’t even realized the project had gotten to that\n phase. The compiler comes as the vacietis.vcc ASDF system as part\n of Vacietis.
\n\n
Some big things that need to be done are struct call-by-value,\n pointer scaling, arguments to main(), some libc stuff, setjmp, and\n making VCC produce linkable Lisp “object” files (fasls) for the\n different implementations. I would also like to change the pointer\n representation to be a fixnum offset into a sparse array (right now\n pointers are represented by structures that look like <offset, array>).
\n\n
Overall, I am amazed by how much progress Vacietis has made given\n how little time I spent on it. I am now convinced that Common Lisp\n is mostly a superset of C, and have a newfound appreciation for\n gotos and PROG.
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
A single-address space Common Lisp operating system based on\n capabilities (Jonathan Rees wrote\n a dissertation on doing\n this in Scheme in 1995) and a virtualized package system. I really\n like Azul Systems’ hack of using the EPT/RVI virtualized page tables\n as a hardware read barrier for real-time garbage collection, and\n with a single-address space operating system I think you can do the\n same thing on hardware with a regular MMU.
\n\n
If you follow the steps of the Viewpoints Research Institute’s\n Fundamental New Computer Technologies project\n and keep the system as simple as possible, it should be a surmountable\n amount of work to realize a somewhat working system.
\n\n
Vacietis is actually the first step in the Common Lisp operating\n system project. I’d like to have a C runtime onto which I can port\n hardware drivers from OpenBSD with the minimal amount of hand\n coding. The way hardware drivers are written in OpenBSD (a set of\n patterns it borrows from NetBSD, where they originated and are\n colloquially known as “bus_dma”) is very pleasant. Theo de Raadt was\n also the first well-known Free Software operating system developer\n to take a position against binary hardware drivers, and I respect\n him tremendously for that. Linus Torvalds doesn’t care, and as a\n result it is now impossible to get drivers for any of your ARM\n devices, even though 99% of them run Linux. OpenBSD will continue to\n have great, stable Free Software device drivers that are easily\n portable for different hardware architectures and to the other\n BSD-derived operating systems. I hope OpenBSD’s model of Free\n Software hardware drivers catches on more widely.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
I tend to design software systems in advance only at the level of\n the domain. I find that programmers who try to come up with APIs or\n draw class diagrams ahead of starting to code tend to write very\n poor code.
\n\n
I rely heavily on interactive programming for doing mundane tasks,\n and since most programming time is spent dealing with mundane\n things, I spend most of my time in the REPL. Fortunately the Common\n Lisp REPL is the best programming environment I have come\n across. Things like the Rails console don’t even come close. The\n only comparable environment is the Unix shell.
\n\n
It’s also very easy to turn Common Lisp REPL code into unit tests,\n which I tend to do a lot. That is something that’s very hard to do\n with object-oriented code, which is why idiotic things like\n dependency injection and Test-Driven Development have to be\n invented.
\n\n
For difficult problems, it’s always better to step back from the\n keyboard and just think about your code. Hacking around in the\n debugger is usually a waste of time (the only exception is when\n you’re having data structure issues, but then technically you’re in\n the object inspector). I mostly tend to debug with print statements.
\n\n
The best productivity tip I’ve come across is the “Seinfeld\n technique” that I learned about from reading Hacker News. It\n involves doing something, no matter how small, on your project every\n single consecutive day, without any gaps or\n interruptions. Apparently Jerry Sienfeld uses a big calendar and\n tries to mark up large “runs” of consecutive days on it. That really\n keeps you focused.
\n\n
One thing I try to focus on in my code is giving unambiguous, unique\n (i.e., easily grep-able) names to symbols. That makes it easy to go\n back to old code and quickly figure out what is going on. Common\n words like “status,” “mapping”, etc. make terrible names unless you\n qualify them.
\n

\n\n

\n $\"Vladimir\"$

Vladimir

\n\n

2013-03-05

\n\n

Marc Battyani (France - USA)

\n\n

Marc Battyani is one of the people who put Lisp at the foundation of\ntheir business, and he doesn’t seem to regret that decision. And the\nbusiness itself is exploring very interesting aspects of\nhigh-performance and reconfigurable computing. Besides, he has a\nnotable open-source contribution with\ncl-pdf/cl-typesetting\nlibraries. He elaborates on all these and more in much detail in the\ninterview.

\n\n

Tell us something interesting about yourself.

\n\n

\n
I think maybe the most unusual things I do is that I work on very\n different application domains which are even sometimes completely at\n opposite extremes both in electronics and software. For instance\n form ultra low power smart sensors based on $1 microprocessors which\n will run continuously for 5+ years only powered by a small coin\n battery up to the world’s lowest latency supercomputers based on\n FPGA costing thousands of $ per chip. On the software side I use\n programming languages ranging from the lowest level languages like\n assembly or even below with VHDL up to really high level languages\n like Common Lisp.
\n\n
I’ve always enjoyed mixing electronics design and higher level\n computer science and all that diversity probably gives me a\n different and original view on say computing and programming in\n general.
\n

\n\n

What’s your job? Tell us about your company.

\n\n

\n
I’m the CTO of NovaSparks a startup I founded in 2008 to make\n ultra-low latency FPGA based supercomputers for the financial\n markets. BTW These things are really incredibly fast. For instance\n on 10Gb/s Ethernet market data packets coming from exchanges like\n the NASDAQ we process the IP/UDP/multicast network stack, extract\n the messages from the packets, parse/decode/filter/normalize those\n messages, maintain the indexed order book data structures, aggregate\n the price levels per stock, generate output messages and finally\n send them to a server through PCI-express or 10Gb/s Ethernet network\n stacks. The nice thing is that we do all that fully pipelined at a\n rate of one message every 12 nanoseconds! To have an idea of how\n fast it is, in 12 ns the light will only travel 3.6 meters (11.8 ft).\n Another way to view this performance is that the system can\n process 83 Millions of financial messages per second without any\n queuing.
\n\n
As an aside it is interesting to note that the Domain Specific\n Language Compilers and various other tools written in Common Lisp\n have been key enabling factors for the creation of NovaSparks.
\n\n
I’m also the CEO and CTO of Fractal Concept which is the company\n where we were developing that technology before starting NovaSparks\n but as NovaSparks has been using more than 100% of my time for the\n last years Fractal Concept has been less active with only the\n development and maintenance of the smart sensors going on.
\n

\n\n

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

\n\n

\n
I’ve always used Common Lisp for most of my work and even when I\n need to use other programming languages (like VHDL for NovaSpark’s\n FPGAs or javascript for web stuff) I generally use Common Lisp at\n least for a lot of related tasks like prototyping, designing and\n testing algorithms, extracting statistics, performing simulations,\n generating test data, analysing test runs.
\n\n
The next step is very often to generate some or all the code in\n other languages by designing various domain specific languages (DSL)\n which will take care of the tedious aspects of programming in less\n powerful languages. I really like it when from a few 100s of lines\n written in a easy to use high level DSL we generate 10000 to 60000+\n lines of very low level VHDL code saving months of development.
\n\n
About that point I think I would even say that I’m mostly doing\n Language Oriented Programming by trying to abstract the domain\n specific knowledge into various domain specific languages with very\n different syntaxes like s-expressions, C like or other languages or\n even sometimes adding to the mix some GUI or data-based inputs. Then\n those DSLs would generate most if not all the application code in\n whatever language is needed be it VHDL, asm, C, javascript or Common Lisp.
\n

\n\n

What brought you to Lisp? What holds you?

\n\n

\n
A friend of mine gave me a version of\n Le_Lisp\n a version of Lisp used in the 80’s by the French universities and\n engineering schools to teach high level programming concepts. At\n that time I was mostly programming in Z80 assembly language on a\n TRS80 and the straight jump from ASM to Lisp was quite a shock and\n an eye opener.
\n\n
Since then I’ve used Common Lisp for countless projects ranging from\n a few hours of work to multi-years ones and I still find it\n awesome. Where else can you find a language providing such powerful\n and multi-paradigms features like CLOS, generic functions, the MOP,\n macros, closures, s-expressions, lambdas, an interactive REPL (Read\n Eval Print Loop), native compilation of applications, on the fly\n native compilation of generated code, the condition system,\n interactive live programming, real time live debugging of running\n software and more!
\n

\n\n

What’s the most exciting use of Lisp you had?

\n\n

\n
I’ve got so many of them than picking only one would be difficult so\n here are a few of them:
\n\n
\n
\nsoftscan: real time\n driving and data acquisition of automated non-destructive testing\n installations with real time 3D display (a first in 1995)
\n
my web application framework: Automatic generation of really\n complex web applications (the whole stuff from the HTML/javascript\n front-end to the server back-end). It has been fully Ajax-based\n with dynamic modification of the displayed pages without reloading\n the page. This seems obvious nowadays but it was also a first in\n 2000 and IIRC the term “Ajax” was only invented 5 years later.
\n
hpcc: The awesome DSL to VHDL compiler. In many aspects VHDL is\n the complete opposite of Common Lisp. It’s a hardware description\n language used to program FPGA and it deals with the lowest\n possible programming level with data types like signals, clocks,\n and bits. Programming at that level is really tedious, time\n consuming and verbose so it’s really a relief to be able to\n generate tens of thousands of lines of highly optimized VHDL code\n from just a few hundred lines of some high level Domain Specific\n Language.
\n
cl-pdf/cl-typesetting: Being able to generate the first PDF files\n from scratch in only 107 lines of Common Lisp was an Haha moment.
\n
\n

\n\n

What you dislike the most about Lisp?

\n\n

\n
The language itself is somewhat good enough and anyway Common Lisp\n makes it really easy to change most of itself to add the new and\n cool stuff or ideas of the day.
\n\n
In fact what I dislike about Lisp is outside the language and more\n related to the (mis)perception that people have about it. Having\n almost everytime to justify its use and sometimes even to fight to\n be able to use it is somewhat annoying and tiresome.
\n\n
Of course, Lisp is not for everybody but this is not a reason to\n have nobody using it. In fact I view Lisp as some kind of amplifier\n which will give awesome things when used by brilliant developers but\n will end up giving an incredible mess when used by people without\n any clues about what they are doing. That’s one aspect that makes\n Lisp very different from other languages which are especially\n designed to try to normalize and average what people can do with\n them.
\n

\n\n

Describe your workflow, give some productivity tips to fellow programmers.

\n\n

\n
I obviously use emacs and all the nice stuff that work with it like\n slime,\n org-mode,\n magit and lots of other packages. I\n switched from subversion (svn) to git for all my projects and I now\n use git mostly form emacs with magit.
\n\n
In general I have several instances of Lispworks running as\n standalone apps on my laptop but connected to Slime through\n M-x slime-connect rather than being started by slime. I do a lot of\n exploratory programming and interactively play with the code while I\n write it and if I have to optimize some code I very often use\n #'disassemble.
\n\n
About my Lisp coding style I really do like generic functions, CLOS\n and the MOP. As mentioned earlier I try to generate as much of the\n code as possible by using macros in simple cases and full blown DSLs\n in more complex ones. Sometimes I do not dislike making some\n premature optimizations when I know that speed will be important for\n some project. BTW when speed matters I like to generate and compile\n code on the fly when it’s useful (and possible) and try to generate\n really optimized code. It’s always cool when you have Common Lisp\n applications running much faster than C++ ones.
\n\n
I also refactor a lot. Generally when I start on some new stuff I\n try to make a first version that works well enough but then once\n it’s done or generally after some time I have some cool ideas to\n make something much better. At that point I’m really happy that\n Common Lisp makes refactoring very easy thanks to optional and key\n args, macros and generic functions with multiple dispatch because\n all that enables me to make even very deep modifications very\n easily. I really find those Common Lisp features make software very\n resilient to code modifications.
\n

\n\n

What are the advantages of using Lisp in the HPC field? What are the drawbacks? Are you happy with your technology choice?

\n\n

\n
The HPC field is huge and I can only talk about the small corner of\n it I know which is the ultra-low latency processing of vast amounts\n of data we do in NovaSparks. For that the various DSL compilers\n generating VHDL code have really been a key enabling\n factor. Programming FPGAs is notoriously difficult and time\n consuming and this is the major factor limiting the use of\n reconfigurable computing in the HPC field. The use of those DSL\n compilers has made it possible to use those FPGA on a more practical\n basis for processing financial data.
\n\n
BTW I’m looking for other HPC domains in which those DSL VHDL\n compilers could be used so feel free to contact me if you have some\n ideas.
\n

\n\n

If you had all the time in the world for a Lisp project, what would it be?

\n\n

\n
Again that’s a difficult choice. Speaking about pure Lisp projects\n I’ve been willing for a long time to clean up and modernize my web\n app framework before releasing it as open-source so maybe that could\n be a good project to start.
\n\n
Otherwise as mentioned above, I’m looking for possible applications\n and opportunities of leveraging the DSL ⇒ hardware compilers and\n the FPGAs around some Big Data processing. I have a few ideas but\n nothing specific for now.
\n

\n\n

Anything else I forgot to ask?

\n\n

\n
A conclusion? (Everybody wants a conclusion.) So here is mine:
\n\n
Common Lisp is Awesome! It is much easier nowadays to use it thanks\n to all the projects and libraries that Quicklisp makes available. If\n you do not know Common Lisp then learn it and this will make you a\n better programmer anyway even if you do not use it directly after.
\n

\n\n

\n $\"Marc\"$

Marc

\n\n

2013-06-12

\n\n

Afterword

\n\n

I hope you’ve enjoyed reading these interviews and have gained\nsomething of them. I surely did.

\n\n

Some events occurred in the professional lives of many of the\ninterviewees even in the short period since the interviews were\nconducted. FarÃ© had left ITA, yet he’s produced ASDF 3, a lot of\ninteresting things of which you can read in\nhis presentation. Zach\nBeane is now part of\nClozure Associates where he hacks\non Lisp full-time and continues to improve Quicklisp. Marijn Haverbeke\nhad a hugely successful Indiegogo project\nTern\nto improve JavaScript editing experience. Peter Seibel went to work\nfor twitter. The next ECLM took place\nin Madrid.

\n\n

The Lisp ecosystem continues its development little by little, yet\nconsistently: new interesting implementations are arriving, new\ncommunity resources are being developed, and more projects get started\nor mature. And, last but not least, hopefully, a new generation of\nLisp hackers is growing…

\n\n

\n $\"(c)$

\n\n","tocStructure",[],"publicChapterContent","nextChapter","sections",[],"routes/_store+/_layout","routes/_store+/_readers+/_layout","actionData","errors"]

Table of Contents

A Short Intro

A Few Quotes

Zach Beane (USA)

Tell us something interesting about yourself.

What’s your job? Tell us about your company.

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

What brought you to Lisp? What holds you?

What’s the most exciting use of Lisp you had?

What you dislike the most about Lisp?

Among software projects you’ve participated in what’s your favorite?

Describe your workflow, give some productivity tips to fellow programmers.

How did quicklisp change your life? What are current plans for its development?

If you had all the time in the world for a Lisp project, what would it be?

Anything else I forgot to ask?

Edi Weitz (Germany)

Tell us something interesting about yourself.

What’s your job? Tell us about your company.

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

What brought you to Lisp? What holds you?

What’s the most exciting use of Lisp you had?

What you dislike the most about Lisp?

Among software projects you’ve participated in what’s your favorite?

Describe your workflow, give some productivity tips to fellow programmers.

Ediware became hugely popular (by Lisp standards), and with this popularity came a lot of work and responsibility. You seem to have mostly handed over supporting it to Hans Hübner. What’s up next for you in the land of programming and Lisp in particular?

If you had all the time in the world for a Lisp project, what would it be?

Slava Akhmechet (USA)

Tell us something interesting about yourself.

What’s your job? Tell us about your company.

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

What brought you to Lisp? What holds you?

What’s the most exciting use of Lisp you had?

What you dislike the most about Lisp?

Among the software projects you’ve participated in what’s your favorite?

If you had all the time in the world for a Lisp project, what would it be?

Describe your workflow, give some productivity tips to fellow programmers.

You’re currently a co-founder of a startup company RethinkDB, which went through YCombinator. As an insider of the startup ecosystem, in your opinion, what are the areas for Lisp use in startups nowadays with the biggest potential upside and why?

Pascal Costanza (Germany - Belgium)

Tell us something interesting about yourself.

What’s your job? Tell us about your company.

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

What brought you to Lisp? What holds you?

What’s the most exciting use of Lisp you had?

What you dislike the most about Lisp?

Describe your workflow, give some productivity tips to fellow programmers.

Among software projects you’ve participated in what’s your favorite?

One of your papers, “Reflection for the Masses”, researches the ideas behind 3-Lisp, “a procedurally reflective dialect of LISP which uses an infinite tower of interpreters”. Can you summarize them here?

If you had all the time in the world for a Lisp project, what would it be?

Anything else I forgot to ask?

Peter Seibel (USA)

Tell us something interesting about yourself.

What’s your job? Tell us about your organization.

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

What brought you to Lisp? What holds you?

Did you ever develop a theory why Lisp isn’t used more?

What’s the most exciting use of Lisp you had?

What you dislike the most about Lisp?

Among software projects you’ve participated in what’s your favorite?

Describe your workflow, give some productivity tips to fellow programmers

If you had all the time in the world for a Lisp project, what would it be?

PCL was the book, that opened the world of Lisp to me. I’ve also greatly enjoyed Coders at Work. So I’m looking forward for the next book you’d like to write. What would it be? :)

Marijn Haverbeke (Netherlands - Germany)

Tell us something interesting about yourself.

What’s your job? Tell us about your company.

Do you use Lisp at work? If yes, how you’ve made it happen? If not, why?

What brought you to Lisp? What holds you?

What’s the most exciting use of Lisp you had?

What you dislike the most about Lisp?

Describe your workflow, give some productivity tips to fellow programmers.

Among software projects you’ve participated in what’s your favorite?

If you had all the time in the world for a Lisp project, what would it be?

You’ve been actively using Common Lisp and JavaScript. When you use JavaScript what do you miss the most from CL? What do you miss from JavaScript when you’re in Lisp land?

François-René (Faré) Rideau (France - USA)

Tell us something interesting about yourself.

What’s your job? Tell us about your company.

Do you use Lisp at work? If yes, how have you made it happen? If not, why?

What brought you to Lisp? What holds you?

What’s the most exciting use of Lisp you had?

What you dislike the most about Lisp?

Among software projects you’ve participated in what’s your favorite?