HN Simulatornew | past | comments | lists | submit | tomjen3's commentslogin

Figma is trading lower now than it did when Claude Design was released with a total stock drop of 56.38% from Nov 10, 2025 to Nov 10, 2026.

So yes, not dead and clearly good for people who want that additional layer of control, but also nowhere where it used to be.


> also nowhere where it used to be

is this about growth, the userbase or the product? userbase is growing and the product seems to work fine; as for growth I'm not sure that was what people talked about when they said Figma would *die* but even then 43% seems fine?


Not sure what people are smoking; figma is seeing huge growth.

Figma also has MCP and other AI features. You can use it in agentic workflows just fine!

It's also not Anthropic only. Or OpenAI only. Businesses are leaning heavily into model and harness diversity, particularly open and bespoke variants..


Lisp missed its timing. When it was above and beyond everything else and a totally different world, it was way too expensive and way too inefficient.

Today, when mainstream languages have stolen much from Lisp, the benefit of using a language where you can generally just add a gem, egg, or crate is much higher than the benefit of the one thing that is still unique to Lisp: macros. Reflection is inelegant as hell when you compare, but it will get you almost all the way macros do.

At the same time, typed languages have become much more like dynamic languages. The types have disappeared into var and let statements; they are now inferred rather than repeated. Pattern matching has been added, and more—without compromising the benefits for larger teams and larger code bases.

Purists will disagree, but I haven't seen a real world problem solved in Lisp that I couldn't also solve in other languages.

And yes, I am interested in being proven wrong. I want to know what kind of problems still exist that are that hardcore. But I suspect a big part of it is that those who code in this still think the "hello world" for Java looks something like this:

    public class HelloWorld {
      public static void main(String[] args) {
        System.out.println("Hello, World!");
      }
    }
when in reality it now looks like this:

    void main() {
      println("Hello World");
    }
and in C# it looks like this:

    Console.WriteLine("Hello, World!");
And comes with full first class support for Linux and Mac.

Lisp is an intellectual tower and has given an incredible amount to the programming community in terms of ideas and a playground for people to try things. I'm not denying any of that — it should be celebrated. But my thesis is this: most of that has been moved, copied, stolen, and adapted to mainstream programming languages.


>Purists will disagree, but I haven't seen a real world problem solved in Lisp that I couldn't also solve in other languages.

Turing completeness makes "I couldn't also solve" an impossibly high bar.

But if what you mean is, you haven't seen macros used in ways that make you wish your day-job programming language had macros, that's fixable.


Not GP and not Lisp programmer. But I'm curious about what you said. If you had to name one popular app or web service (>10,000 monthly unique users) that'd be much easier to clone in Lisp than in Python or Rust, specifically due to macros - what would that be?


I'm not active with any Lisp these days myself, either. Back in Web 1.0 days, when a lot of apps were transforming streaming rows of SQL results into grouped HTML entities, I used macros to implement something akin to SQL's LEAD and LAG, but at the application level. I don't have time, so I have to leave it as an exercise to the reader why it would take more verbosity to implement this in another language.

https://brl.sourceforge.net/brl_4.html#SEC31

Now, as a non-Lisper, I have to wait and hope the maintainers of programming languages I use will take useful syntax from other languages. Back when I was an active Lisper, I could take such syntax myself.


Is there any such syntax remaining? Sure, 20 years ago it was a pain to do manipulations of more than 1 element at a time. But nowadays everyone and their dog has some form of iterator combinators that make it a one liner. Even C++, although the line gets quite wide. Is there anything that, as of 2026, you seriously miss having in your day job language (and that language isn't Java)?


I'm having fun in TypeScript and only casually missing the capabilities of macros. It's Turing-complete, so doing the equivalent things is a simple matter of programming. And I'm almost always processing JSON structures, not SQL result rows, so I don't miss being able to write syntax like `sql-repeat` on a day-to-day basis.


Languages are no more Turing-complete than they were 50 years ago. If lack of Lisp macros was such a huge deal back then it affected day to day web development, then surely it must be affecting us all in this day and age too. Arguably, using JSON instead of SQL should make such macros even more important due to the unnesting of data we need to do. So why isn't it?


About today, JavaScript is good at referencing JSON. You don't need macros to make it better at it.

About back then, Perl/PHP/Python/Java/Ruby were never as good at pulling groups out of rows of SQL, but people could work around that by taking more time, writing more code, being more careful. So if you haven't seen macros used to make it better, you don't realize you're missing out on a huge deal. Maybe you just have a vague idea that things could be better, but you're too busy finding and fixing bugs to pursue this thought.


In other words, as of 2026, this phrase:

> if what you mean is, you haven't seen macros used in ways that make you wish your day-job programming language had macros, that's fixable.

is not true at all anymore? Or is it only true under very specific circumstances (if so, what are they)?


True if you would like syntax that doesn't lend itself to eager evaluation. In the `sql-repeat` example, `group-beginning?` takes an expression that can't be eagerly evaluated. It's evaluated twice, once for the current row and once for the previous row, and the result of evaluation is compared. It can't just be eagerly evaluated for the current row and the result used.

Also true if you want a shorthand syntax for defining a variable where the name of the variable is meaningful. JavaScript takes care of the most common case with destructuring assignment, but with macros you could make such syntax yourself.


Macros don't make it easier to 'clone' software. They make it easier to write software, any software.


And arguably harder to read and maintain other people's software.

Don't get me wrong I'm a macro fan. I've worked with some elegant codebases using metaprogramming but it's been challenging bringing people up to speed with super clear efficient - but novel - code,

Other projects that were just down the line Java boilerplate built on a well understood library worked just as well in other ways.

Personally I think reducing cognitive load is key, I've found people don't have the energy to work with clever code, even if it makes writing it a delight.

... and then llms happened, and I now don't write code at all but closely review a fire hose of mediocrity that gets the job done. I don't want that too magical.


> the one thing unique

it's the developer experience

(and the combination of all features, including homoiconic macros)

> a real world problem

You can solve anything with enough sweat ;)

One example? Routific's core algorithm is written in CL (source: its author on HN). Why not Java, like everybody on his field at this time? Because it was too tedious (edit: and we're not talking only about syntax) (there's a blog post somewhere). His prototype evolved in efficient production code, now the heart of the company.

> my thesis: most of that…

agreed on "most". Many features appear here and there in other languages. But there's the parts and the whole.

And the living platform ("stop writing dead programs"), still unique (with Smalltalk).


As big Smalltalk / Lisp / ML languages fanboy, I mostly agree with you.

In fact the main reason I hang around Java and .NET as my main tools, is that those development environments have taken many key features from those programming languages and development experience, to the point that where they still lose to them isn't that much relevant.

Additionally, now with AI code generation, the actual programming language matters even less, natural language can be translated to whatever programming language one feels like, at the whim of a Markdown paragraph describing the desired output, assuming it is supported on the model being used.

However it is kind of sad that we lost the last AI wave from Lisp/Prolog to Python, losing good machine code generation in the process.

And I have seen many real problems solved with Lisp, regardless, that is why commercial Lisps like LispWorks and Allegro are still in business.


> And I have seen many real problems solved with Lisp, regardless, that is why commercial Lisps like LispWorks and Allegro are still in business

Can you think of some domains where Common Lisp is a better choice than other languages? I have enjoyed Clojure for a lot of things, but I have not really found the features of SBCL useful for the kind of work I do.

For instance, restarts without unwinding the stack are cool, but for a server that's going to be running in production, it's not something I really leverage. I could use conditions to change the context of code called downstream, but I just haven't had a reason to do this yet.


Siscog, a Portuguese company well known in the community.

https://www.siscog.pt/en-us/

This is an old blog entry about their Lisp history, https://www.siscog.pt/en-us

https://www.siscog.pt/en-us/blog/35-years-of-lisping-at-sisc...

Then you have ITA Software bought by Google, and the reason they have Lisp style guide,

https://www.itasoftware.com

https://google.github.io/styleguide/lispguide.html

Autocad has used Lisp as main scripting language for quite some time, although they also do .NET as well nowadays,

https://help.autodesk.com/view/OARX/2026/DEU/?guid=GUID-037B...

Note that everyone talks about SBCL, but forget that the ones that survive the Lisp machines like experience are LispWorks and Allegro Common Lisp,

https://www.lispworks.com

https://www.lispworks.com

Which if you want to have a taste how it looked like back in the day, some folks are trying to keep Interlisp-D memory from Xerox PARC alive.

https://interlisp.org

https://primer.interlisp.org/introduction


> I haven't seen a real world problem solved in Lisp

Bruh... Nubank is literally the biggest effing digital bank in the world. Famously built on Clojure stack. Just because you have not seen shit it doesn't mean it's not happening.

Apple, Netflix, Amazon, Walmart, NASA - they all use Lisp, and that's just the States. There are tons of European startups building on it.

> Lisp missed its timing.

It is literally timeless. Emacs just turned 50. Name a single half-a-century old software product that's being actively used, developed and improved. r/emacs subreddit gets daily, daily! updates of new Emacs package announcements.

> most of that has been moved, copied, stolen, and adapted to mainstream programming languages.

Totally. Except homoiconicity. The point of which the majority of programmers miss, misunderstand, or ignore. The bigger point programmers miss is that Lisp effectively proves that largely the syntax of programming languages doesn't really matter. What matters is the runtime. And Lisp today runs practically on every possible runtime. Meaning that to be a polyglot, you don't really need to know dozens of PLs, you can just understand homoiconicity and voila - you can practically ship software for any runtime. Syntax is the cheap part, and Lisp shows it well: Clojure on the JVM and CLR, Clojurescript on JS, Fennel on Lua, Hy on Python, LFE on BEAM, Jank on LLVM, etc. The surface stays the same, and the host changes underneath. Then you learn runtimes and type systems, which is the real work of being a polyglot. That is a big win. Most programmers spend years on syntax and then mistake it for knowing a language. Learn the damn Lisp. It is enormously practical.

> still think the "hello world ...

Who the fuck cares about intricacies? In pretty much [almost] every Lisp dialect it would be just:

(print "Hello, World!")

For EVERY different runtime.


Or just "Hello World" running under the repl


Look up price versus intelligence for your favorite open model on artificial analysis and compare it with Luna, Sol, Opus, and Sonnet. Mind you, all of those are API prices, and you're still better off paying API prices than using an unsubsidized open model. Subscriptions from any of the major labs are an even better deal.


The major issue is going to be you ran your stuff dry with agents and now you are cut off from the chats. If instead, like 1% had been reserved, then you'd automatically be able to use the website and it would cut off people who set up skills to hack around it, which I suspect is why they're doing this.


All types of architecture have advantages and disadvantages. Clean code might not be very cache-friendly, but it does a pretty good job of making sure you don't have to hunt in too many places to update things and It also makes it pretty simple to split things up so that you can write unit test for most everything.

This is not the right choice for everything, just as using Python is not the right choice for everything. The question to ask is: what are we trying to do in the first place? Then take it from there.

You did that by making sure the speed-up was business relevant. I'm mostly putting this out to force people to think about whether that also applies to their specific thing.


"Clean" code for modelling links between objects would be to store pointers within them. But that means dangling pointers when deleting objects, so you need to either update manually everywhere (easy to forget somewhere) or use shared/weak pointers (extra bookkeeping and allocations).

"Unclean" code for this is putting objects in a table, giving objects a generation (that increments whenever you create/delete one) and storing pairs of (index, generation) numbers everywhere you need a link. Link is live only if the generations matches and since only odd generations are live objects, default construction means no link. Lifted straight from 2000s video game tricks and with modern C++ it's basically all encapsulated away.

I've made that refactoring in a codebase, not because of speed but because of maintenance and memory fragmentation concerns. Sometimes, the clean solution really isn't the right one and it's really sad that compsci only ever teaches classical data structures, like we're still coding in the 1970s on computers with no caches that don't suffer from pointer chasing.


It was built by nerds but optimized on the data of everyone, so it ended up appealing mostly to the average person.

Maybe that's also the solution to a question I've had for years. The ads I see on diverse social platforms are terrible, but if they are matched with algorithms that try to fit me in as an average person, then it makes sense that, as a huge nerd, they miss the mark.


Ad algorithms are horrible everywhere. Why are you not blocking them?


I'm sure there are places that would sue you for that, and it's not worth the bother. Bug bounties really compete mostly with people like me who would say, "Haha, I found an issue with Meta; they're gigantic idiots." And then make an X post or anything about it.


I don't necessarily feel bad about it, but I do feel sad about it.

I would not want all my bread to have come from wheat being milled on an old watermill, but I love visiting those as museums, and I think it would be bad if they were torn down.

I probably feel about the same for JetBrains. Plus, I have fond memories of using them.


For a while I agreed with you, but then I realized I want my agent to have access to the same find references, index, and rename tools, and the rest of the refactor tools that JetBrains have always provided me. And I wanted to be able to use those, even if it means I'll have to pay for Jetbrains.

Just like it was inefficient for me to manually rename variables and classes, it's token inefficient for my agent to do that.


Yeah! Refactoring, is already a solved problem, and deterministic with IDE (unless you have an untyped Python codebase), now we are reinventing the wheel, in more broken ways?

Want to add an additional parameter without creating a thousands of error? Change signature, Extract a part of code to another function? Extract Method.

People are taking these small, but extremely useful conveniences, without waiting, without paying for tokens, for granted.


In theory you’re right it’s an often repeated talking point but I just don’t understand why am I worth advertising to but not worth creating products for? The products I see advertised are either stupid or so overpriced that it means buying them is stupid.

I am entirely willing to spend money and I have decent savings. I just expect the products put on offer to be worth buying.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: