Hacker News Reader

Very cool story; thanks for sharing!

I think a major fault in the industry is "find somebody who's good at X". It's not a necessary or even optimal requirement. Common Lisp doesn't have too many particularly odd language features; I'd say learning the Rust borrow checker or Scheme's call/cc is more difficult than anything Lisp has to offer.

What organizations need to do is prepare to let smart engineers self-train on the language as a part of on-boarding, instead of making it a hard job requirement to know the tools before walking through the door. In my experience, even for good programmers who are pretty green in their career, are entirely productive in just a few weeks—maybe a month total. That includes learning a new language, a new editor, and a part of a new code base.

Perhaps counterintuitively, the hardest people to teach Common Lisp to in my experience have been "senior software engineers" who transition into the project, who are so dead-set on their preferred languages and tools that they're entirely unwilling to even try something new, even if they're being paid to do it. Instead, sometimes, they'll find it preferable to do political maneuvering to avoid it, either by carving out a new module in their language, by petitioning to rewrite it, or by prioritizing other things entirely.

> Perhaps counterintuitively, the hardest people to teach Common Lisp to in my experience have been "senior software engineers" who transition into the project, who are so dead-set on their preferred languages and tools

That's essentially my experience. There is something about developers... they learn a new language but most people never really learn a new way of thinking.

I worked with one guy who tried to learn Common Lisp and even after a year on the project his code was essentially Java written in Lisp.

But this isn't really a problem with Lisp, specifically. I had the same problem with pretty much every programming language. Just recently I had fun debating the usefulness of Kotlin as a programming language. In my experience, for all the features Kotlin has, every single Kotlin program I have ever seen looks like a Java program translated line by line to Kotlin. Which is to say none of the Kotlin features are actually used to solve any important problems like reducing complexity of the application.

> Common Lisp doesn't have too many particularly odd language features;

I would say for most developers I worked with the biggest challenge was always getting the idea of macros. There is technically no reason to use macros. But if you do not use macros you are not really programming Lisp.

The point of macros is the reversal of the programming process. In a regular programming language, you get a bunch of tools and then you learn the tools and then you figure out how to write program using the tools.

In Lisp, you figure out how you want your program to be written, and then make tools that make it possible. It is quite a big shift in thinking that many people have trouble with.

Once I got this, I am now using similar technique in other programming languages. I am looking at my problem and extracting the core complexity and try to figure out what would be the best way to write that complexity down as code. Then I figure out all the machinery to make it happen. It not as elegant as in lisp but it still leads to way better and more readable code at least where it matters.

"Anyone could learn Lisp in one day, except that if they already knew Fortran, it would take three days." — Marvin Minsky

The irony there is that someone first had to learn enough Fortran to invent the FLPL (Fortran List Processing Language) system that went on to inspire the impelmentation techniques and terminology of Lisp.

> The sad part is that it was impossible to get anybody else working on it and I had to rewrite it in Java (and destroy performance in the process).

Java has a CFFI and while it ain't pretty, I don't see where the performance impact would come from, when machine code is to be injected and the critical path is in machine code / C.

> extremely low level (like understand what the CPU does when it gets an instruction) as well as the highest level (complex abstractions with Lisp macros, etc.)

Those skills don't seem all that far apart. I'd rather think it'll be difficult to find someone willing/able to encode and maintain financial / legal safety limits in machine code :-}

I can't speak for onetimeuse92304, but it's probably because the program which generates machine code was in Common Lisp and SBCL using the techniques FTA, and it would basically be impossible to port in any reasonable way. Experimenting with and deploying assembly code generation in SBCL is very organized and flexible—much better in Lisp than in C even.

Technically, you can write a compiler in any programming language. So yeah, you can do it in Java, too. But why if Lisp already has a compiler built in that you can use for the advantage. That's pretty much the idea.

I also happen to know Java (almost 20 years of experience with it).

The point of rewriting it to Java wasn't just the Common Lisp. Compiling and injecting code into high throughput, live, mission critical application proved to be too much of a challenge for developers we tried to hire. Even if I rewrote this for Java (which I absolutely had no intention of doing) the problem would still persist. Most Java devs have even worse understanding of the low level operations than Common Lisp.

What does “destroy performance in the process” mean? Was the performance being destroyed the performance of something that needed to be fast?

Bravo