this is some lovely dark marketing, an innocent insider conversation, prompted by a single developer, Xalavier Nelson Jr., who might or might not have been encouraged by Larian marketing team, gets blown up into a narrative piece by a literally who game news sweatshop. the narrative here is that "the game is so good, how can other games compete", as a concern troll, communicated by the developers of lesser games themselves. so bold as to be comedic! much respect to Dominik Warkiewicz.
(hello, you are one of the people that have greatly inspired me many years go!
in the early hackerspace days there was a lot of talk of diy, but it was a kind of consumer lifestyle thing, like stitching a new strap to your laptop backpack. I think the accounts of your projects, and your adventures, put me in the direction of thinking of diy as not some kind of external activity, but as the default mode of living. solving problems from first principles, refining them from experience, solving your own problems with solutions that are fundamentally superior to off the shelf consumer stuff, because they are driven by your own needs and knowledge and experience.
my vessel of choice is a dinghy, and it's built from a kit, and the waters I navigate are much gentler than yours, but everything else is diy and jury rigged, and I sometimes would say some solution is "in the spirit of timonoko", and sometimes people ask "who's timonoko" and I say "oh it's this crazy cool Finnish kayaking guy, he wrote his own navigation software from first principles, and he wrote his own lisp, and he got into all kinds of amazing kayaking adventures"
I remember spending some non-insignificant amount of time playing 3dpong, because that was the first time I got exposed to a wireframe game. I thought the formalism was delightful, it felt very cyberpunk. My first 3d game was probably Stunts, a racing game that used flat shading (there was also Abrahams tank, but I never got into it as much as some of the older people in my circle), and then there was a lot of games that used a kind of hybrid sprite, flat shading, texturing mapping approach, from wolfenstein to Daggerfall. I got 3dpong from a Slackware cd, which was also my first linux install, back when linux was cool :> I was democoding, so probably implementing phong reflection on a sierpinski cube which was a style at the time, and here was a game that established an entire 3d experience space with just a handful of lines.
(some might ask "how the hell did you not know about Elite or Tempest??" before pervasive internet discovery was a non-linear process, I think I learned about these games in the early 2000s, from the internet)
Feel like Stunts is such a sleeper retro game so many played and nobody ever talks about. Incredible fully customizable levels with massive obstacles rendered in 3D. In 1990, 3 years before doom.
I sometimes think we collectively rewrite our past for the common denominator. have people always been doing that, or it's an internet phenomenon? like maybe you listened to Andy gibb or The Bee Gees in the 70s, but you retrospectively remember that you somehow was Black Sabbath's biggest fan, even though that wasn't the circles you've spent time in at all.
I sometimes have to consciously remind myself that I haven't played chrono trigger until 2005, or that I clocked some unreasonable amount of hours playing rise of the triad, Star Wars dark forces and Ultima underworld, rather than the whatever's on the list of top 90s video games.
don't forget that besides microcode much of the lisp machine logic was implemented with PALs, which were themselves programmed in Lisp. the simple gates, mixers and flip-flops were describe with lisp code, so that the logic could be tested on the lisp machine. I don't know if they built the test tables using the lisp code, or wrote them out manually, but you essentially had multiple sources of truth that could be mutually verified: lisp code, test tables, and the behavior of the specific PAL.
oh look, it's the balanced and measured lisp skeptic.
If you're going to construct commenters taxonomy, you should include yourself in it, because "I really like lisp, but surely we can rationally agree that the world/we/commercial shops/society has moved on to C" balanced and measured meta-commenter has existed since at least usenet comp.lang.lisp lisp days.
oddly enough this kind of meta-commenter primarily appears in lisp threads. possibly because lisp is one of the few languages that started in 1950s and is being used still, to the utter confusion and dismay of the balanced lisp skeptic.
this meta-comment fundamentally has a faulty premise, that the single dominant language development paradigm is the exclusive one. this was not true in the 90s, when it seemed all but inevitable that the computing world is going to standardize on c++ or java, but it's particularly faulty now, when heterogenous stacks are significantly more popular and the overall number of developers, with varied interests and preferences has increased.
the second faulty premise is that the mass of development and corporate preferences somehow matter in viability, particularly in such an individualistic field as computer programming. personally I reach for Common Lisp when I need to solve a problem where I understand neither the problem nor the solution, what's known as explorative programming. having established the parameters of the solution, I can then communicate the architecture to senior programmer team. the solution then will be communicated by people like you as "success story for Java", ignoring the fact that the successful architecture might have not even materialized without a lisp prototype. many lisp success stories are like that.
if you already understand your solution space, then the value of lisp is equivalent to any other dominant language, and things like library support and easy development availability become core differentiator. lisp is not the only language in this space, smalltalk come to mind, Julia, and to a lesser degree mathematica and Matlab.
so we're going to continue to use lisp in our special and mysterious ways to the utter dismay and confusion for people like you "but guys guys we've moved ooon!"
While your defense of Lisp and its historical significance is admirable, I believe your critique oversimplifies the realities of software development and unfairly caricatures those who favor more mainstream languages. The adoption of a language in commercial settings isn't a dismissal of Lisp's merits, but a pragmatic choice driven by considerations such as maintainability, developer availability, and the robustness of language ecosystems.
It's not about moving "on" from Lisp as if it's outdated, but about moving "with" the ever-evolving field of programming where different languages serve different purposes. Despite Lisp's strengths in exploratory programming, its steep learning curve, and a relative lack of widely used libraries and tools compared to languages like Python or Java, can make it a less practical choice in certain environments.
Moreover, attributing a project's success solely to its initial Lisp prototype overlooks the fact that many different languages could be used to prototype effectively. The successful completion and deployment of any software involve various factors beyond the choice of initial prototyping language.
There's room for a multitude of languages in the programming world, each with their strengths and weaknesses. Dismissing those who choose other languages as simply not understanding Lisp's value is an oversimplification and fails to account for the complex factors that influence language choice in different scenarios.
You've been repeatedly making a number of fallacious points here, which can be summarized as:
1. Lisp is a single language, with one fixed set of trade-offs, rather than a large family.
2. Lisp has been around for a long time, and isn't developed any more and has only historic significance. People who work with Lisp are essentially retro-computing hobbyists, not keeping up with what is going on.
With regard to (1) Lisp is a fairly large family, and the members are different from each other. The strength and weaknesses of, say, Gauche Scheme are not the same as those of Armed Bear Common Lisp (to pick a random pair).
There are Lisps that give you general purpose programming on Unix or Windows: multiple programming paradigms and access to the entire platform. Anything the system is capable of doing, you can do it through Lisp.
With regard to (2), there are certainly some people who are into retro-computing in regard to Lisp. For instance, a few people have revived the historic Interlisp iplementation from the 1970. They have it running with its windowing system and all. There is an active trading market for old Lisp hardware like Lisp machines of various kinds. Sure.
By and large though, people who are working with Lisp of any kind for real work are using something contemporary that is being developed. Just like people working with C (also an old language by now) are likely on a recent Clang or GCC, and not Borland Turbo C 2.0 for MS-DOS. Lisp people move on from old Lisp implementation, like they do from old C or Python implementations.
You're dismissing the existence of new Lisp dialects, and of continuing development of existing older implementations.
You're also dismissing the possibility that contemporary Lisp programmers might actually know Python, Go, C# and so on. Including ones who work on maintaining implementations.
People who knows those other things and some kind of Lisp or two probably make better informed decision in regard to whether or not they use Lisp, that those who don't know any Lisp.
I see your points about the wide variety of Lisp languages and their ongoing development (SBCL, Clojure, Racket, Emacs Lisp, for instance). My intention was not to oversimplify Lisp or its significance, but rather to highlight some challenges that may hinder its widespread adoption. I agree that Lisp continues to evolve and that many modern programmers use contemporary versions of the language for real work.
However, despite the ongoing development and evolution of Lisp, it seems that its adoption in commercial settings may still be limited due to factors such as maintainability, developer availability, and the robustness of language ecosystems. I’d be interested to hear your thoughts on how these factors might be addressed to increase Lisp’s adoption in these environments.
I also agree that those who are knowledgeable in both Lisp and other programming languages likely make better-informed decisions regarding language choice. In your experience, how do these programmers navigate the choice between Lisp and more mainstream languages in different scenarios? I look forward to your insights.
Without specifics about what its you're talking about, I have no idea what you're talking about.
What do you understand as Lisp? Does it include Clojure, Janet or Hy?
Every project has its unique struggles.
The adoption of absolutely everything outside of some half dozen popular things is virtually nonexistent. It has nothing to do with their syntax, because the field is full of wannabes striving for popularity of their project, by means of deliberately imitating the syntax of what is popular. It's not working; they're only ruining their project with garbage ideas for nothing.
Most of what is not popular is non-Lisp. Making a non-Lisp is as good a path to unpopularity as making a Lisp.
Some Lisp-likes are integrated into popular run-times and can use their ecosystems. Robustness of the ecosystem is obviously a non-issue for them. They can be used gradually; like a few files of some project written in another language can be in the Lisp-like. That counts as a valid use.
The main factor that influences language choice is not knowing anything else. For large numbers of new programmers, that narrows it down to one, and all other factors become moot. For most others, there is some additional reasoning regarding which of two or three to select.
It's just weird how people like to show up in threads about niche languages specifically to tell people that their language is dead and/or that C or Go is better. Let people use the tools that they like.
I absolutely agree with you that everyone should be allowed to use the tools they prefer. My intention is not to denigrate Lisp or to suggest that it is 'dead.' I appreciate its role in computer science history and its unique strengths.
However, it's also important to understand that the purpose of discussions like these is to exchange perspectives and understandings about the different tools we use. The objective is not to declare one language as the 'holy grail' and demean the rest, but rather to acknowledge that each language, Lisp included, has its strengths and weaknesses, and is more suitable for certain tasks than others.
While Lisp is excellent for certain tasks such as exploratory programming, other languages like C, Go, or Python might be better for others due to factors like their robust libraries, wider community support, or greater ease of readability and maintenance.
I suspect if various stakeholders (u.s. senate, various corporate interest groups, etc) understood the implications of the home computers, they would've not hesitated to ban and otherwise regulate them. Up until early 2000s home computers were seen as toys for nerds (people forget!), a perspective that I'm sure many of them now regret.
oh man so much confusion, and everyone's grifting, and I kind of suspect that the paper itself relies on ignorance to stir up a little controversy.
Iberian horses moved from south to north. English horses from east to west. This should be obvious why. Spaniards landed in Mexico, with the landmass northward, which is also the direction of their exploration. Anglos landed on the east coast and explored westward, the whole Oregon trail business. There's a point sometime in 1700s when English riding anglos were interacting, trading and warring with Iberian riding indigenous peoples.
What this paper focuses on is the details of south to north Iberian movement. The specific scientific arguments that it's making, supported by phylogeography and archeology is that the adoption of the Iberians by the indigenous tribes with some probabilities happened sometime between 1516 and 1599, and that with some probability dates of samples in specific states fall in some period between 1600 to 1700.
Next there are two simplifications that exist in general lore, and arguably in historic lore. The first one is the idea that horses were introduced by the Anglos on their westward expansion of the American frontier. The second is that Iberian horses were introduced to indigenous tribes predominantly during 1680 pueblo revolt (in future new Mexico), when a whole bunch of Spanish horses were stolen.
The first simplification exists because there's a lot of cowboy movies, and it's just a pop understanding. Nobody really cares about horses anymore. But equestrians know that there's at least vaquero tradition, and Baja California is one of the last surviving places, where men ride Iberian horses in Spanish style. vaquero ranching was dominant on the west coast, it was never "erased", but it was forgotten along with cowboy ranching in general. little known fact, but "buckaroo" is English riff on "vaquero".
The second simplification is the strawman that this paper for some reason decides to construct. It references a 2017 book, where the 1680 pueblo revolt is presented as a kind of turning point, where downtrodden Indian slaves, who were all trained by Spanish, stole some Spanish horses and rode into various tribes. The problems is that 1910 and 1930 articles that this paper references, and the first person accounts that the articles reference themself, despite being written by colonists and cowboys, were still written by serious equestrians so they don't even remotely support this comedic take. Possibly the Pueblo revolt narrative became dominant recently as an attempt to give agency to indigenous peoples.
So now one is ready to understand the political point that this paper makes: between 1600 and 1700 Indians have developed their own sacred equestrian tradition, and that this happened before and independent of Pueblo revolt and definitely by the time the anglos crossed the continent. The problem is that any serious equestrian (I dunno about anthropologists though) already agrees with this conclusion. Existing historic papers don't disagree with this conclusion either, and support it at least in terms of "yeah we went there and they already had horses".
From this perspective Charles c mann is just straight up grifting, trying to imply that indigenous equestrian tradition existed even before the Spanish, and there's a lot of people in his comments that decided it's a done conclusion.
And the fact that some North American horses didn't come east to west is also a well established fact, that unfortunately very few people know, but it's not a novel discovery this paper made.
I'm going to answer to myself, since above is already a tl;dr and it's unlikely that these comments will attract any kind of attention. Note to self. There's a subtler political point that the paper is trying to make, neither vaquero tradition, nor historic accounts by colonists can strongly testify to the existence of indigenous sacred tradition in the 1600s. This are my suppositions, but I suspect what when the various conquistadors were exploring North America, they wouldn't be privy to the burgeoning sacred equestrian tradition of the indigenous tribes. By the time anglos cross the continent and establish strong enough ties to learn of such a sacred tradition, it becomes impossible to date exactly the tradition's beginning. The paper tries very hard (with talk of care, and quotes from tribe representatives) to establish that such a tradition was already establish in the 1600s, so by the time there was a contact with anglos, indigenous peoples really really knew what they were doing.
according to any Andy Gavin, the cofounder of Naughty Dog and a MIT AI lab alumni, crash 1, 2 and 3 were written on GOOL/GOAL[0] which was a home-brewed lisp. According to Franz themselves, the language was hosted on allegro common lisp[1]. the language gave him an ability to push ps1 platform to its limits by leveraging the kind of thinking that's part of lisp lore: incremental recompilation of a running ps1 instance using a remote little language written in and hosted on a Common Lisp dynamic environment. the previous sentence describes a poorly understood practice that of a dynamic environment leveraged development that was part of lisp machine and smalltalk machine and a handful of other now forgotten approaches. in a sense crash was not just "written in lisp", it was written leveraging lisp machine like thinking, that Gavin would've been familiar with from his MIT AI days.
when naughty dog got sold, all the remaining Gavin lisp systems were eventually stripped, so that the company for all intents and purposes became a standard c++ shop. some time later some hipsters wired plt scheme[2] as a scripting language for the Naughty Engine 2.0. unlike the original Gavin approach this is not some deep leveraged architectural decision, and it being lisp is pretty irrelevant to the sort of capabilities it provides. imho scripting language for a game engine selection is a lipstick on a pig kind of process, as demonstrated by various basic-like potato languages that came with legendary triple-As.
It's the Reddit story all over. Lisp devs know Lisp + X, but everyone else only knows X, so we'll use X instead -- even if it's inferior and causes issues down the line.
This isn't really limited to Lisp though. It applies to quite a few languages with the excuse of "market forces" where "market forces" really means "we want to makes sure our devs are easily replaceable cogs" (using a niche language actually pressures both sides to stick together because the dev can't easily find a new job and the company can't easily find a new dev).
It's slightly different: Naughty Dog had proven that they can deliver commercial successful applications (novel platform games on the Playstation with excellent content) using Lisp. They had their own IDE on top of Common Lisp and as a delivery vehicle a Scheme-like runtime.
They were bought by a much larger C++-Shop (Sony) and were trying to get the benefits from a larger eco-system. In the end they were bought for their talent, their experience, their brand - but not for their technology.
For Naughty Dog it could also have been the right moment, since from a certain point in time the game platforms are getting so complex that making custom inhouse game runtimes may no longer make sense for smaller game studios.
Reddit OTOH had never delivered anything commercially successful in Lisp, little experience with Lisp, but heard that it could be cool. They used unproven tech. Naughty Dog used proven tech and had enough experience to do low-level systems programming for a brand new game platform. Which is really an outstanding achievement. Reddit had only a rough prototype in Lisp, Reddit then switched inhouse to other technology.
Naughty Dog only switched because they were bought out by Sony who then demanded that they change languages.
Reddit was merged with another YC company. That company used Python, so they switched everyone to Django. Last I knew, most of Reddit’s outage woes were still due to the outdated ORM they are stuck with. In any case, Common Lisp is hardly “unproven Tech”.
> Naughty Dog only switched because they were bought out by Sony who then demanded that they change languages.
To reuse a larger code-base, instead of working on their own new platforms for the next systems.
> In any case, Common Lisp is hardly “unproven Tech”.
Common Lisp is a language. Software is running on implementations and SBCL was relatively new then (2005).
They used SBCL which at that time was not used to implement such websites.
Naughty Dog used Allegro CL, which was already used in a bunch of 3d/OpenGL applications. Their own runtime was custom build and required real deep expertise in implementing a GC-less Scheme for an embedded platform.
Reddit could have switched to a paid Common Lisp variant without any trouble if they'd actually had issues. The people there said they moved to Python because that's what the other team knew. I don't see a reason to argue otherwise.
The argument behind the Naughty Dog switch was also pretty clear. Sony wanted to be able to move devs between projects easily and everything else used C++, so they'd rather force Naughty Dog to use C++ than tell everyone else to learn Common Lisp. To my knowledge, there was zero discussion on the merits of one or the other and it was a business call.
Further, the reams of custom code Naughty Dog now has written on Racket points to them still loving lisp and not minding if they have to invest a lot of effort into being able to use it in their designs.
> Reddit could have switched to a paid Common Lisp variant without any trouble if they'd actually had issues.
I thought they had issues. Didn't they?
Paid Common Lisp variants tend to get expensive and even for those, the main applications rarely were high-traffic websites with UI frameworks.
Take ITA Software / Google, they were developing core business logic of the flight search engine in Lisp - the product than ran/runs in SBCL. They had a team of 100+ people and a bunch of the top Lisp talent of that time. They also invested a lot into improving SBCL.
> Sony wanted to be able to move devs between projects easily and everything else used C++, so they'd rather force Naughty Dog to use C++ than tell everyone else to learn Common Lisp. To my knowledge, there was zero discussion on the merits of one or the other and it was a business call.
A business call is based on assumptions: larger ecosystem, more libraries, shared runtimes, etc. That's all much more economical than doing it alone as a small studio.
> Further, the reams of custom code Naughty Dog now has written on Racket points to them still loving lisp and not minding if they have to invest a lot of effort into being able to use it in their designs.
Of course they love Scheme and they were then back creating their own content delivery tools. But they stopped implementing runtime things like core 3d graphics animation frameworks for new CPUs/GPUs, etc.
Things were more complicated than that with Reddit from what I've read (and from a now defunct blog post they wrote not to mention various talks and interviews from devs who were there at the time).
Their devs were using Macs in 2005 which ran on PowerPC. Their servers were x86, but running FreeBSD (honestly, that was a tall ask for most languages in 2005). They had an issue finding threading libraries that worked on that OSX/PPC and FBSD/x86 combo. They further complained that there weren't tons of libraries available for use either. Finally, they also made some bad architecture decisions unrelated to Lisp.
The switch is still a weird one if you move aside from the new team not knowing or wanting to learn Lisp. Python isn't threaded at all, so they could have stuck with non-threaded CL and still have had 100x faster code. Likewise, they wound up rewriting all the python libraries they were using because those libraries turned out to have tons of issues too.
Naughty Dog continued using Lisp for game development throughout the Uncharted series at least, I'm not sure about The Last of Us but I would be very unsurprised if that changed.
They just stopped having the game written nearly purely in custom Lisp dialect, instead only mostly - effectively switching from GOAL setup of Jak&Daxter run-time to similar approach to GOOL in Crash Bandicoot - core written in C/C++ running considerable portion of game logic in Lisp (variant of PLT scheme in Uncharted).
Uncharted dev tools were also built in PLT Scheme (aka Racket).
