The Art of Lisp and Writing (2003) | Hacker News Reader

The Art of Lisp and Writing (2003)

dreamsongs.com

205 pointsBogdanp114 comments

I used to feel similar when I’d write Python. It was a beautiful language in its primordial days, and you’d feel like a hipster renegade if you could sneak it into an enterprise environment where C#, Java, and C++ were the norms. Even just whipping up a tiny script that didn’t require compilation and could do some stuff felt like magic.

These days I mostly write Go for work, and as I’ve gotten older, I no longer find the act of programming profound. I take more joy in hiking and kayaking than programming, since LLMs have commoditized something that used to be gatekept to the teeth.

I’m glad that AI tools have trivialized many parts of the act and let people focus on the result rather than the process. Kind of like how good linters completely killed off the bike shedding around code aesthetics.

That said, nowadays I appreciate tools that last. Languages that take backward compatibility seriously and don’t break user code on a whim. Languages that don’t support ten ways of doing the same thing. Languages that don’t require any external dependency managers or build tools. Languages that are fast, have less syntactic noise, and let me do my stuff without much fuss. So to my eyes, those useful languages are the most beautiful.

So Python, with its bolted-on type system, no built-in dependency manager (uv doesn’t count; there will be more unless they put it in the standard toolchain), and a terrible type checker, doesn’t really appeal to me anymore.

I’m sure anyone could write a beautiful ode to any language of their choice and make something profound out of it. If I could, I’d probably write an ode to Go.

> since LLMs have commoditized something that used to be gatekept to the teeth.

I don't see any LLM commoditization and I can't apprehend your point of view that programming was guarded by gatekeepers. The past 20 years have been an explosion of systems, open code, and languages. Where do you get this point of view from?

That is the mindset that the industry has drilled into programmers from 2015-2024 (everyone must learn how to code).

This worked for OSS corporate employees who pretended to promote equity while always keeping their own leadership positions.

Since the layoffs, corporations stole all open source code via "AI" and are now selling it back to the authors while humiliating them ("you have been gatekeeping!").

Totalitarian projects like CPython, whose "leaders" jumped on any corporate bandwagon and have yelled "gatekeeping" on any occasion, are now guarding the leftover places and the GitHub lock icons have increased exponentially (many of them have been fired).

As you say, all of this is just self-serving propaganda and there has never been any real gatekeeping in programming. especially when compared to law or medicine.

Today, one of the remaining appeals of Lisps (e.g., CL, Scheme) is that (aside perhaps from Clojure) they're not very employable, and so the communities and ecosystems are more old-school hardcore in sensibility.

In Python, I have to really get on a roll on a project in it, to where I can ignore most of the unfortunate aspects, that are apparent when having to Web search through writing and code that seems 99.99% by people who wouldn't be doing this if it didn't pay money. Many are skilled and professional and conscientious, despite the circumstances of it being a job, but that's not the norm.

In JavaScript universe, jeebus, you can't read about even the smallest things, without it cavalierly telling you to install a supply chain disaster from NPM.

In Rust, some of their linguistic thinking is appealing. They still have the positive-employability problem, :) but the difficulty has a gatekeeping effect that isn't entirely unwelcome (if you only want a job, just learn JavaScript or Python). I can foresee flexing some of my systems programming skills like I haven't been able to as much in Python, JavaScript, or Scheme, to build efficient and trustworthy software. But then, for example, the other day, I thought "I'll try this UI package, which is a wrapper around a platform Web rendering widget, since maybe they found a sweet spot..." But somehow, "hello, world" requires compiling 503 Rust crates, just for the wrapper alone, not counting the code for the non-Rust platform Web widget that the they wrap. We already know that the platform widget is going to be buggy with memory errors and design flaws, and we're going to be running bloated Web stack atop that widget, and with callouts to Rust code, and how many people in the world can even reason about debugging that (or auditing it!), just to display simple GUI widgets in a fashionable way.

> Today, one of the remaining appeals of Lisps (e.g., CL, Scheme) is that (aside perhaps from Clojure) they're not very employable, and so the communities and ecosystems are more old-school hardcore in sensibility.

One of the reasons why I wrote 42links in Lisp is that it’s less likely to end up in a ChatGPT reply without any license hints.

Ironically, this author gets the relationship between lisp and writing totally wrong. Lisp may be much more artistic, but programming in Java, for instance, is much more akin to writing than programming in lisp is. Written languages have well established vocabulary and grammar, that cannot be changed or redefined by the writer. The author is completely correct that lisp is more of a "programming medium" than a "programming language", since the language itself can be molded and changed by the programmer in very self-expressive ways. However, he doesn't follow through with this observation to the obvious conclusion that this feature of lisp, as a medium, makes it fundamentally different from human language.

I don’t think that’s the right take. Poetry manipulates common grammatical rules and still communicates meaning from the writer to the reader, perhaps in an even deeper way because of that manipulation. Of course in Java and many other programming languages, grammatical errors will simply not compile. LISP is one of those few languages where grammar can change from program to program, much like with poetry

Even though there is much more freedom in poetry, it is still defined by a specific set of rules/features: verses, rhythm, stanzas, spacing, meter, and rhyming. It's only because of these restrictions that it is so obvious when writing is or isn't poetry. These features and forms can streched, but unlike lisp they cannot be completely redefined.

You’ve got to read more poetry before making assertions like this. In practice, the definition is more fluid than that.

Lisp cannot be completely redefined. You can’t avoid parentheses, and if you stray too far from common idiom, you’re no longer writing Lisp, you’re writing something else using Lisp syntactic forms.

100% agree, the comments reveal a confidently incorrect opinion based on limited and cursory understanding of poetry, and literature at large.

> You can’t avoid parentheses

Well, you can with reader macros, assuming you’re willing to consider an init file that you only look at when you write sufficiently avoidant.

It’s not done though, because experience has shown it’s not really worth it.

> It's only because of these restrictions that it is so obvious when writing is or isn't poetry. These features and forms can streched, but unlike lisp they cannot be completely redefined.

I disagree here. To take rhyming as an example. It's possible to have a poem where every line rhymes AND a poem where there is no rhyme at all. It's not as simple as saying 'okay the lines in this text don't rhyme so it can't be a poem'. The same is true of the things like spacing and meter. These are all massively variable, and the result doesn't even have to be bound by the usual rules of grammar. English - or any other natural language - is much more variable than Lisp.

For me the defining feature of poetry is that the form and nature of the language used in a text may suggest meaning over and above what the individual words say. This definition is subjective, and suggests that the poetry is in the eye of the beholder, but is more honest than a simplistic checklist of features to look out for.

I didn't say poetry has to have all of those things, but it has to contain some of them or it simply isn't poetry. I would challenge you to find me one good example of poetry that has none of the features I listed.

This whole poetry topic is really besides the point anyways.

> English - or any other natural language - is much more variable than Lisp.

I don't feel like you are actually addressing what I'm saying, so let me reiterate it more clearly. I'm not making any assetions about the absolute creative power of lisp or writing. It is the author of the article who points out that lisp's distinguishing feature, compared to other programming languages, is it's ability to specialize and mutate its own verbiage/syntax to better fit certain problems or modes of thinking. I am simply pointing out the irony that this charactistic of lisp also distinguishes it significantly from natural language, even though the author is attempting to argue that programming lisp and writing literature are similar.

In writing you are free to adopt any structure and style and make new ones.

In Lisp you are more inventing your own vocabulary and grammar.

And there are still rules. This is a dumb argument about the degree to which an analogy holds.

English Language is the best general purpose conveyance of arbitrary ideas, and it has syntax rules just like programming languages. It's "best" by the metric of being "easiest for humans to understand". That's what I mean by best, in this case.

I think one can argue that LISP is the "best" computer programming language based on a set of metrics that revolve around simplicity and composability. There's no simpler language. There simply cannot be, because there's nothing "extra" in LISP. It's the most compact (while still being human readable) way to define and/or call functions.

You can also argue that LISP is closer to English than any other programming language, because in English we use parenthesis's and lists to enumerate things related to what has been said. For example "(add, 1, 2)" is axiomatically the best way to express adding two numbers, in a way that scales to arbitrary numbers of operations. It's superior to "(1+2)" because the plus sign is a single character (cannot scale), and therefore there are a limited number of them, and using symbols means humans have to memorize them rather than simply reading their name. But "add" is a name one can read. Also "add one and two" is a valid English sentence, so all LISP programs are similarly valid English language expressions, where the parenthesis is merely used for grouping language "clauses".

If the world were ever to be forced to agree on one single high level programming language, it would necessarily need to be LISP for about 10 other huge reasons I could name: Everything from ease of writing parsers, to compression of code, simplicity, ease for learning, even as a young child, etc.

> English Language is the best general purpose conveyance of arbitrary ideas, and it has syntax rules just like programming languages. It's "best" by the metric of being "easiest for humans to understand". That's what I mean by best, in this case.

Given that most people alive today don't understand English at all, I don't think this claim holds up very well.

> For example "(add, 1, 2)" is axiomatically the best way to express adding two numbers, in a way that scales to arbitrary numbers of operations. It's superior to "(1+2)" because the plus sign is a single character (cannot scale), and therefore there are a limited number of them, and using symbols means humans have to memorize them rather than simply reading their name.

I'd be willing to wager that "1+2" is understood by far more people across the globe than "(add, 1, 2)".

* I use "English Language" as a synonym for "Human Language". However even if you want to be pedantic and interpret all my words in the literal sense, everything I said is still literally true.

* I never said LISP format was widely understood.

> I use "English Language" as a synonym for "Human Language".

That was unclear given you kept calling out English, and not natural or human language more broadly in the rest of your comment. But I'll go with it.

> all my words in the literal sense, everything I said is still literally true.

No, they aren't. You need to make a stronger case than "Because I declared it axiomatically true".

+ has become part of nearly every language already, what's the value of picking one word (add) from one language (English) to replace it? Or to be more generous to say that every language should substitute for + whatever their language's word is. Now they can't communicate without a translator. Or, they could just use + as has been done for centuries. Why make things harder on ourselves?

The point about `(+ 1 2)` v.s. `1+2` is about the fact that the LISP syntax generalizes to all computations, whereas mathematical expressions do not. The beauty of LISP is that one simple syntax solves everything about computation in the axiomatically simplest way possible.

> one simple syntax solves everything about computation in the axiomatically simplest way possible.

So what about RPN? What about Forth and Postscript? Just as simple... just as terse... just as efficient... just as general.

And, for me, just as unreadable.

I don't think RPN is as simple as parenthesis.

All RPN does is replace the easy to get right parenthesis with difficult to get right newline characters.

Reverse Polish notation is every bit as easy, simple and minimal as Lispian prefix notation. They are mirror images of one another... and for most ordinary people, both are equally difficult to read or to use.

And I include myself in this.

Remember that for a lot of ordinary people, school algebra is almost impossible to follow and is the reason they stop studying maths as soon as they can. And that is simple infix notation.

> RPN is every bit as easy [as LISP]

Riddle me this then: When editing code full of parentheticals, why do devs find it helpful that IDEs can find and highlight the matching opening/closing parenthesis automatically? I mean, based on your logic, parenthesis just don't make things any easier, right? I'll leave the topic of "indentation" completely off the table too, because a single riddle is enough.

I don't know what side you think I am arguing for here, but it's not the one you're guessing.

Yeah, I did't think you ever genuinely believed RPN is easier than LISP.

No, that is not true.

Me personally? I dislike them both. I find them both unreadable.

But both are compact and efficient... just really difficult.

You are trying to put words in my mouth that are not there. That is very rude. Do not do that, ever.

But also, as you have been throughout this thread, you are wrong.

The parenthesis in LISP make it dramatically easier to deal with than RPN; and I don't believe for a millisecond that you objectively disagree with that fact.

Lisp would be vastly less readable if the parentheses were removed, and arity had to be worked out according to the definitions of the functions and operators, understood to be working on an implicit operand stack.

Think about it: the entire class of error of mismatched stack height doesn't exist in Lisps.

There could be an operand stack, if the Lisp is translated to a stack-based byte code; but it's managed so the programmer isn't concerned about it.

Yeah, RPN is essentially what you'd get as output if you compiled LISP using a compiler. Claiming RPN is as easy to deal with as LISP would be utterly absurd, and no one genuinely believes that.

Well, RPN with parentheses, as a layer of syntax, would be easy to deal with. That's what Lisp backwards would be.

  ((a b +) (a b) add defun)

  (((list pop) print) list while)

It helps me to read it in Japanese:

"A to B wo tasu, A to B no paramēta no aru, 'add' to iu kansuu wo 'defun' shite."

"lisuto wo 'pop' shite, sore wo insatsu shite, lisuto ga kara de nai aida ni"

Interesting things happen. When we think about how 'add' is called, we follow it from right to left, contrary to the direction of speech of the Japanese sentence. The function add is called, the (a b) parameters receive argument values and the (a b +) is evaluated.

However, the chained application expressed by nesting, which people complain about being backwards (so they need to invent piping/threading macros to go left to right) now reads left to right! We do have to evaluate the while condition first, but then the pop and print to left to right.

Yeah, the Japanese incorrectly put verbs at the end of the sentence! Just like Yoda does. Asian he must be. Incorrect they all are.

But seriously, yeah computers are naturally 'Stack Machines' [almost] always, where they need the arguments pushed onto a stack before the 'verb' is executed.

Even if we don't think about stacks, but just the raw data dependency: before we can perform an operation, we need to determine its operands.

So if we translate that sequence to language, stating the operands before the operation does follow the non-negotiable evaluation data flow.

That's why we have interpreters and compilers: So we can make code easier to read. FORTRAN was originally invented as a way to let humans think in terms of parenthetical groupings for math and functions, specifically to _avoid_ reasoning in an RPN way.

What programming systems used RPN prior to 1957?

Doing ASM ~ "RPN reasoning".

> There's no simpler language. There simply cannot be, because there's nothing "extra" in LISP. It's the most compact (while still being human readable) way to define and/or call functions.

I guess you have not gotten into stack or array programming languages yet?

Forth is insanely compact and then there is APL which is a complete other ballpark.

Or check out Rebol for a homoiconic language in a very different syntax.

Lisp is amazing but oh boy there is whole other world out there. It is just one possible local optima. One that I personally love but not the only one.

I wouldn't exactly call APL simpler than LISP. Just because there are some things in APL that _can_ be coded with less characters doesn't make it overall simpler or even more compact in the general case. It's just axiomatic that for a language you need the ability to define and call functions, and it's just a debate about whether there's a simpler syntax than LISP or not, and I say there isn't.

This is the point I take issue with. I agree with you that lisp is the simplest and "best" programming language. Unlike lisp, there is no clear "best" natural language that is more simple and composable than all other natural languages (I know that's not what your claiming, just pointing that out). The dimension of your "best metric" for language is pretty bizarre though; all you are saying is that spoken/written language, in general, is better than grunts and pointing. If you actually compare the space of natural language and the space of programming languages, which is much more interesting imo, I think you would have to agree that non-lisp programming languages are more similar to natural language because their development was more practical and unprincipled than lisp.

The reason I say LISP is close to English is because it's syntax is purely a verb followed by objects, and there's [practically] no other symbols in the language other than parenthesis.

Since the word "best" always gets everyone's dander up on HN, I was very careful to point out we have to define our metrics (of comparison) before we can use that word, and that's precisely what I did.

Very wrong, you are.

Written languages are not static. You can absolute introduce your own vocabulary and grammar. Yes, you might become harder to understand for someone unfamiliar with it but so can get a Lisp program when macros are over used. It is an art after all.

This is especially insane when talking about English. What English? American English? What group? African-American English that introduces whole new grammatical concepts? Indian English? Even two people grown an raised in London can have wildly different ways of speaking depending on their class backgrounds and many other factors. There isn't one English.

And it is ever evolving. Shakespeare English is vastly different than 21st century English. In fact Shakespeare himself invented roughly 1.7k words that we still use today.

Not sure what you are arguing with in my comment because I never said that languages are static; obviously they change. But to pretend that language, as practiced today, is not well defined is absurd. Every part of English grammar and syntax has been methodically systemized, and this information is widely taught in public education programs. Some common set of definitions/rules (may vary by people or region) is conformed to by speakers of the language.

Oh, the police is gonna show up if I verb something that isn't a verb? People only ever use grammatical constructs and vocabulary that they have learned in school?

It is super common for authors to introduce new words or bend the grammar. Again, bloodydamn Shakespeare invented so many new words! Oh, and bloodydamn is such an invented word from a very contemporary and popular book series called the Red Rising series. You don't even need to be high brow to invent new words and get away with it.

I urge you to explore more literature and poetry. There is more to English than what they teach you at school.

> Oh, the police is gonna show up if I verb something that isn't a verb? People only ever use grammatical constructs and vocabulary that they have learned in school?

That's not at all what I said in my comment and I'm not at all refuting your point that languages change and can vary depending on who is using it.

> Every part of English grammar and syntax has been methodically systemized

No, it hasn't. None of it has, ever.

So far, you have been wrong about writing, about human language (specifically, English), about programming languages (specifically, Lisp and Java), about poetry, and about the rules of English and how they're set.

I am intrigued. Is this performance art? What next?

> No, it hasn't. None of it has, ever.

Are you denying that dictionaries and comprehensive books on English grammar exist?

I wonder if they've heard of Burroughs, or even Irvine Welsh.

Could you provide an example of a Lisp program where macros are overused?

Have you seen LOOP[1]? That example barely scratches the surface too.

As for being able to make words mean different things and break grammatical strictures; that’s called poetry when we do it in English. And yes there is bad poetry, but some is superlative.

[1] https://www.lispworks.com/documentation/lw51/LWRM/html/lwref...

I love Richard Gabriel's writing. "The Structure of a Programming Language Revolution" (https://www.dreamsongs.com/Files/Incommensurability.pdf) is both insightful and beautiful.

Thank you for sharing. It's a shame that while reading this I get the feeling of prose I associate with fiction. Where there's no reason for that to be the case.

"outside enormous puffed clouds dwelled overhead, lit from beneath by the town of Porto de Galinhas on the Brazilian coast; the smells of burning sugarcane and bitter ocean pushed into my room." is not the kind of sentence one would expect to find in a scientific paper, but I think the paper is improved by it.

The author also has an MFA in poetry

A bit like pg, who also studied fine arts.

https://en.m.wikipedia.org/wiki/Paul_Graham_(programmer)

Why is it a shame? Is it a feeling that causes you to suffer?

I view it as a shame that I haven't encountered more instances of prose in this (scientific/technical) context. I think it adds to the 'quality' of the piece. From a selfish point of view I would enjoy if I encountered more of this style of writing while being introduced to topics. Although, I'm also not contributing any writing of any quality to any corpus. So there is dissonance there.

As a complete aside, I thought your writing here http://canonical.org/~kragen/memory-models/ was helpful. And I now know about BNF!

I agree about the style. I often find higher-quality prose in older papers, prior to 01950 and especially prior to 01900.

Thank you very much!

When on Gabriel's site, take the opportunity also read about Cadillac, and Foundation for a C++ Environment.

How it became XEmacs, what the Cadillac protocols remind you of on a famous editor currently, the infrastructure for a image like development environment for C++, all around early 1990's.

https://dreamsongs.com/Cadillac.html

This was a wonderful read.

It's a bit sad to see that the book he's referring to at the end is a book released in 2003, to which this is the foreword.

Lisp is an incredible experience to write and experiment in, unlike any other language I've ever worked in.

Still, I believe there are many people out in the field that are mostly about "just delivering the spec" or about making money; pragmatists who care not too much about the art behind the software, and I suspect that will always remain the case.

Craftmanship marrying art and mastery is a niche, but that doesn't mean it's not thriving in spaces for enthusiasts.

> ... but that doesn't mean it's not thriving in spaces for enthusiasts

Seconded by an enthusiast posting on a site written in Arc then rewritten in SBCL ; )

I think it was Arc that was rewritten in SBCL?

> Lisp is an incredible experience to write and experiment in, unlike any other language I've ever worked in.

I think that the experienced of Smalltalk is very similar in some ways, despite the languages themselves being very different. At the end of the day I prefer Lisp, in large part because I feel that it interoperates with the rest of my system better (I could be wrong — no doubt expert Smalltalkers have figure out solutions to all the issues which annoyed me once upon a time).

They’re both roads not taken. It’s sad, and I think that our industry would be in a much better position had we not wasted decades in the C trap. But history unfolded as it did. Maybe it had to.

The author spends a lot time describing programming as a solitary activity (discovery, analysis) using like metaphors (poets, explorers, etc) and draws his conclusions thus, emphasizing the malleability of LISPs and Smalltalk as ideal for this task.

I think the author examining the fads of agile or XP would draw quite opposite conclusions if they observed programming as a social activity, building a shared knowledge and understanding that is constantly refined before it is "abandoned" as a piece of software.

I think the tragedy is that we don't have fluid ways to move between them, that these different development modes (solitary and social, dynamic and static) have produced philosophically and practically incompatible tools and methodologies.

I think he was at the AI Lab in the 70s and consequently familiar with that sort of programming activity. Maybe he just hasn't found it as creative, or as enjoyable, as I have.

The author is Richard P. Gabriel https://en.wikipedia.org/wiki/Richard_P._Gabriel and he had a rather long and impressive career in software.

It is also worth noting that Gabriel wrote this in 2003. At that time, programming was a much more solitary activity than it is today. Git would not exist for another two years.

But we had several distributed version control systems, and collaboration online was rather mature

WRT the earlier comment, I don’t see anything in RPGs writing that assumes solitary development

> we had several distributed version control systems

None that worked well. There is a reason Git took over this space. Git is to 2005-era version control systems what Google was to Ask Jeeves and Alta Vista.

> and collaboration online was rather mature

As someone who experienced this era first hand, I respectfully disagree. Online collaboration was certainly possible, and it certainly happened, but it was not even close to what I would call "mature". It was a colossal PITA. Again, there is a reason that Linus wrote Git, and it was not just that he was bored and needed something to do. He needed a tool that would make remote collaboration on the Linux kernel less of a PITA. And he succeeded quite spectacularly.

I've been realizing lately that we're already to the point where LLMs can basically take written English language and create the computer code it's describing. I think in the future perhaps most (and eventually all) software can be written basically the way we write method/function documentation today. You describe a function, give it a name, describe it's inputs/output arguments. And with enough specificity there will be a [perfect] function that can be written (multiple of course actually) which accomplishes what's described. So we can create entire applications this way. I guess this is already being called no-code or low-code systems, but I think perhaps as a universal language where instructions MUST be given, perhaps LISP is indeed the best because anyone can learn the syntax in basically a couple of minutes.

I can't see how, in 100 years (or maybe even just 50) humans will still need more than ONE computer programming language. Or at the most two. We might always need C++ to exist for low level stuff, but we only need ONE higher level language.

> LLMs can basically take written English language and create the computer code it's describing

Not really.

I know people think they are... but then some people think water can magically be imbued with healing powers.

Here's how that works:

https://www.howdoeshomeopathywork.com/

LLMs are 99% hype. They can't think, or reason, or count... or program.

The way I do most of my coding nowadays is by describing (in English) to Claude LLM what I want done, and it just does it, while I sit back and watch it type. It's amazing. You should learn to code!

> You should learn to code!

What makes you think I can't?

Because no coder in 2025 still says LLMs can't code.

https://andrewzuo.com/apple-study-says-ai-cant-code-4ca19779...

https://leaddev.com/technical-direction/ai-models-cant-under...

https://www.codeflash.ai/post/llms-struggle-to-write-perform...

https://community.openai.com/t/llms-seem-to-be-flawed-at-the...

It's late, I couldn't be bothered to search for more than 30 sec.

Your statement is as incorrect as your others.

There's definitely still a subculture of people who look for things AI can't do yet, and try to parlay that into evidence AI can't do much at all; just like there's Flat Earthers who're similarly dedicated to a cause.

In other words, what you are saying is "I believe and your evidence cannot change my mind!"

That is the core position of all religions. Faith over evidence.

The evidence is that I sit back and watch Claude write code all day long every day.

Not enough.

1. Is it any good, though? Does it work well?

2. Is it better than you could do by hand?

3. Do you care that the vast environmental footprint of the racks of servers that are vastly inefficiently wasting energy to do your job for you – badly – are destroying the planet and meaning that my child has no future?

Because I care a lot about that.

AI is already superior to humans for 99% of coding tasks. It can do a day's worth of coding in seconds, and write code better than even the best humans. Thousands of times better. Thousands of times faster.

In the past several weeks I've accomplished what would've taken me several YEARS to do, pre-AI.

I think you are both fantasising wildly and also generalising falsely from yourself to others.

But throughout this thread you offer no evidence, no citations, just your own extremist unsupported opinions, mixed with ad hominem abuse. I am done. If I knew how to block people on HN I would block you.

^^ That was perhaps the best "psychological projection" I've seen in decades.

Having developed in a wide variety of different languages in my free time, I really think the idea that languages like lisp and smalltalk give a sense of creative freedom is pretty overblown.

I have realised recently that there are much more concrete barriers to creative expression in coding: many of us are carrying around iPhones that you cannot write applications for, even for yourself, without paying a $100 a year fee. All the ways the language makes you feel means little compared to whether or not you can actually write code for your computer. The person who makes the computer can decide if you are allowed to be creative with it. And, as a society, we have decided (or perhaps been implicitly brainwashed?) to not want to be creative with our computers. In such a situation, the distinction between Java's OOP and Lisp's "computational ideas and expression" means very little.

A bit of a "Stallman was right" moment for me.

And that has what exactly to do with Lisp? Pretty much irrelevant to the language itself.

Well a major topic of the article is about the creativity that lisp affords compared to other languages. I’m pointing out that there are much more ultimate restrictions on creativity than programming language. I.e. whether the “powers that be” even allow you to program

Also looping back to the article, it speaks about how lisp and smalltalk have fallen out of fashion which can explained by the more ultimate loss of permission and desire for creativity

I rather be creative for mobile devices while using Swift, Objective-C, Java or Kotlin, with their Smalltalk and Lisp influences from Xerox PARC work in what an IDE is supposed to be and language frameworks, than being stuck on the C and C+ mentality[0] that they are the only true way to develop for small devices.

[0] - I really typed C+ and not C++ on purpose.

Sure, I’m not saying embedded programming in C is the way to go. That’s just a totally different thing to mobile app development

That's why you should compare languages in proper environments, not make an irrelevant point about some mobile development platforms.

Is it irrelevant to creativity in programming and whether or not people use Lisp that the most commonly used computers in the world can't be programmed?

Yes, because that's not an issue with Lisp and therefore irrelevant for the comparison between Lisp and other languages.

Both Stallman and Rossman are right (in that regard) as far as I am concerned.

Now I do not mean to be rude, but I want to really drive a point home: what you are saying sounds to me like "Advances in medicine are not so relevant, because medicine is too expensive, and people in Africa cannot pay for it anyway".

You are mixing 2 totally independent things. That Apple exist, with all the bad things (and also the good) has nothing to do with how a programming language is designed. And all things being equal, people can feel more freedom to express their programs in one or other language, independent of what platforms are avaialble to later deploy them.

Note that while today Apple exists, there is Linux, which you can really do anything you want with, with total freedom (except of some little places with blobs if you are purist) but again, nothing to do with programming languages.

Well they are both relevant to what it means to be creative and what allows for it.

If the king banned painting and someone wrote an article comparing the creative differences between oil and watercolour, I would also then point out that the difference is minute compared to the king banning painting

And that there is a country where painting is allowed does not mean it is not a major restriction for so many of us, or indeed we should not be so individualistic to say “just move”. I care how it affects others, not just me

I think the comment above is applicable because programming is closer to writing than to medicine.

A good example is the web. When it was given to us by Tim-Barnes Lee, the web was a free ecosystem with a simple markup language. But companies like Google decided that this was not a good thing, and now to develop a simple web site you need to know dozens of technologies, otherwise your web page will be considered outdated and disregarded by web search engines.

The same process happened to programming languages, only the ones that could be molded to the needs of large companies were deemed to be "good".

I love your comment, even disagreeing with the first sentence (I used Common Lisp and Swift yesterday - there is a difference for me).

I also don’t like the hurdles of writing private Apple ecosystem apps. Apple may fix this via Playgrounds, not sure though.

I feel captured by Apple’s ecosystem, and that is not a comfortable feeling. Also, Richard is right, we just don’t listen.

It is a scary feeling, and scary to know how much people don’t care

Stallman was right and that only becomes more clear to me with each day that passes. But there is a big difference between having the legal/technical ability to do something and that being at all practical. I'm becoming increasingly more concerned about the practical aspect rather than the technical.

Take the issue of freedom of speech. While it may be legally protected to various degrees, with the US having one of the strongest protections, is it practical when all communication happens on private platforms with opaque filtering ("moderation")?

I see the same thing in programming freedom. Android might technically be "open source" but it is no more practical to actually hack the software on your Android phone than an Apple phone. Similarly, PCs might be available that are under the complete control of the owners, but you need to be an expert programmer to realise this control.

Lisp is simply a more practical language to begin hacking. Emacs is probably the best example. Everything is there to make it easier to hack. It's not just technically free, it's practically free too.

The so called free speech is a technical advantage that gets lost by self-censorship applied by most of the media in the US. A recent example is people (who I disagree with) talking against vaccines, or major movie companies censoring topics that they don't like. This happens all the time.

This is a primary reason why I do not use Apple products. I use Windows and Linux on my laptops, and even have a ChromeBook. I use a SteamDeck as a console. I use Android phones, tablets and eReaders. I use Android based TVs and streamers. Even if I never code a line for them, I like that I could.

The world Lisp was born in is more like your iPhone example than the intervening years were. Lisp is older than POSIX by 20 years.

I’m aware. Why bring that up?

I think this contributed more to the demise of CL than is recognized. It was cmucl, sbcl, and other free implementations that kept it alive thru the 90s.

I don’t begrudge Franz and others their licenses, but what happened with the LMI and Symbolics IP is a cultural disaster.

There is a difference. I write a Lisp program, and it runs everywhere Emacs does, including my Android device. I wouldn't do that with Java, as thaw would be extremely impractical. (I might be biased: I probably wouldn't be programming at all if Lisp didn't exist.)

Lisp is the №1 enabler of Stallman's “Freedom 1”. Smalltalk might be close but I can't really say, and it doesn't look like I can install Pharo on my Android device. Nothing else even comes close.

pfff... Lisps exists pretty much for every platform and domain these days. You need to target JVM - here's Clojure. Javascript - Clojurescript and nbb. You need system scripting - you can use babashka or Janet. OTP - there's LFE. You need iOS/Android development - there's ClojureDart and ReactNative. Low-level systems programming - try Carp or Ferret. Data science and numerical computing - Hy gives you Python interop and there's clj-python/libpython-clj. Microcontrollers and embedded - uLisp covers it. Academic/research work - still can't beat Common Lisp or Scheme.

The OP is wrong about creative freedom being overblown. Lisp gives you creative freedom - if you choose to accept it.

lisp's power came from its default being openness. not just macros or homoiconicity, but how the system assumed you would reshape it. that expectation isn't present in modern languages. today, customisation is an advanced feature, not the baseline. we talk about lisp as a language, but it behaved more like a writable substrate. the cultural part wasn't romanticism it was just people using what was there without artificial walls

Yes but that power proved to be a weakness as well.

so much of programming has been shaped by fads than I don't think you can safely point the finger at 'everything is a dsl' as being a root cause. back when lisp was really being put out to pasture, it seemed like the major complaints were about performance and syntax. and how if it wasn't object oriented then it really belonged in the dustbin (of course ignoring clos and the mop)

I'm sure of that but it seems that LISPs being too flexible hurt their adoption rate somewhat and the mainstream preferred to have more guardrails on their programming languages. Ultimately developers are the ones who decide what they like and popularity quite often reflects what's being done commercially. I agree about the fads part.

(2003, with some footnotes added later)

I think that Python has inherited a lot (but unfortunately not all) of the artistic qualities of Lisp. So in a sense the artistic dynamic approach of Lisp won given the popularity of Python.

I find Python a pretty rigid and boring language. There are no macros, the syntax is infuriating, it is mostly OO these days.

You can do introspection and access the variables at runtime (using a horrible syntax), but that's it.

I don't see much artistic aspirations in the language or in its creators. Ruby already has a much better metaprogramming story and the code looks more elegant.

reply to parent and grandparent:

> Python looks like an ordinary dumb language, but semantically it has a lot in common with Lisp, and has been getting closer to Lisp over time.

> They might even let you use Ruby, which is even more Lisp-like.

https://www.paulgraham.com/lispfaq1.html

I think the first versions of python were implemented in lisp. I believe this is why docstrings are the same in both.

Reply on news.ycombinator.com