19 ms·

Why Lisp?

271 points by susam 5y ago

kazinator 5y ago
Lisp is very good even if you write all your code into text files and invoke a build command before running it, which you do in a completely fresh image. If my only way of debugging were to upload the compiled image onto an embedded target and observe the effects of print statements a serial log, I would still overwhelmingly want to be using Lisp.
jmkr 5y ago
Having never used Common Lisp, it's one of the languages I wish I've used for a long time. However, working with Clojure and Scheme, I understand the power of repl driven development that is difficult to explain outside the experience of it.
- threatofrain 5y ago
  But repl workflows are not special to Clojure and Scheme. People in JS set breakpoints in their IDE, pause at a point in their script to interactively explore program state all the time. Is this not the same?
  - gotts 5y ago
    >Is this not the same? not even close, no
  - joshlemer 5y ago
    I'm also curious, I think what it comes down to is that Clojure lets you change the code of a running application, rather than reload it.
    - jimbob45 5y ago
      You can do that with C# in Visual Studio though.
      - Nihilartikel 5y ago
        The greater Clojure hot-reload super power comes from embracing the idiomatic division of state and function though. Hot reload in C# will have probably have to re-instantiate classes or restart the app. In clj, if your application state is kept in a global atom a'la (defonce app-state (atom {})) Then redefining your functions won't touch your data. The only reason to do a full restart would be if you changed the data structure expected by the functions in a way that's not semantically backwards compatible. Big-whoop on a stateless webserver, maybe, but on the front end using ClojureScript for an SPA it is nothing short of magical and has ruined any other browser dev work flow for me.
        mikelevins 5y ago
        ...and Common Lisp and Smalltalk take it a step further. You can go ahead and change the data structure in a way that's semantically incompatible. The runtime will notice that the definition has changed and either automatically reinitialize any existing instances to conform to the new definition, or, if it doesn't know how to do that, pose a UI asking you to tell it how. And when control reaches a function that expects the old kind of object and runs into an error, it'll enter a breakloop that you can use to modify the now-out-of-date function to handle the new definition properly. Once you've redefined the function you can then tell the runtime to resume and it will proceed as if the function you called had originally had the new definition.
  - mumblemumble 5y ago
    It is not quite the same. I'd argue that, while browser environments are very good, they're trying to solve a slightly different problem, and the overlap in capabilities is less than complete. Lispers sometimes say that the browser devtools experience is about halfway toward the power of a good Lisp environment, but I would argue that the converse is also true.
  - hencq 5y ago
    Part of it is cultural I think. In Clojure you'll often find yourself building your app incrementally, sending individual functions to the repl from your editor. I don't think there's any reason why you couldn't do that in Javascript. Common Lisp takes this to another level though with stuff like restarts. Where the app will throw an exception during development (perhaps because a function isn't implemented yet) and instead of crashing you'll end up in the repl where you can make some fixes and keep running the app.
    - susam 5y ago
      There is a nice little story in the book Practical Common Lisp (Peter Seibel, 2005). Quoting it below: An even more impressive instance of remote debugging occurred on NASA's 1998 Deep Space 1 mission. A half year after the space craft launched, a bit of Lisp code was going to control the spacecraft for two days while conducting a sequence of experiments. Unfortunately, a subtle race condition in the code had escaped detection during ground testing and was already in space. When the bug manifested in the wild--100 million miles away from Earth--the team was able to diagnose and fix the running code, allowing the experiments to complete. One of the programmers described it as follows: Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem.
      - CodeGlitch 5y ago
        I've heard this before and it does sound like the most epic hack in the history of programming.
      - e12e 5y ago
        > 100 million miles That looks like about 9 light minutes away, so about 18 minute latency? It might be super epic, but doesn't sound super nice :)
      - Qem 5y ago
        Recently there was a bit of a fuss when people discovered the Mars Ingenuity helicopter runs python3. Now I wonder, if its software ever crashes, will people be able to just launch the python REPL and debug It?
  - _peeley 5y ago
    Not really. With Clojure you don't even have to leave your editor (I use Emacs with the fantastic CIDER package). You can put your cursor over an S-expression, hit two keys, and evaluate and see the results of the S-expression directly within the text buffer. The feedback loop is so quick it's basically instant - even tabbing over to a browser or terminal window feels lethargic in comparison. I haven't used Common Lisp much, but I've seen a few really impressive demos of debugging in its available REPLs. This is a longer one, but a good tour of SLIME (also an Emacs package): https://youtu.be/_B_4vhsmRRI https://youtu.be/_B_4vhsmRRI
    - user3939382 5y ago
      In PhpStorm I hit a hotkey to set a break point, then a hotkey to make the API call to that code and immediately get an xdebug breakdown of the entire state of the program at that point. It’s almost instantaneous and I don’t have to switch windows. I would say that’s pretty close, although the upfront learning and config to get that working means it is higher overhead overall.
      - slifin 5y ago
        For context I use phpstorm and Clojure Here is a video I recorded which hopefully demonstrates just how much faster you can go in Clojure https://youtu.be/L0af0bc5Jec https://youtu.be/L0af0bc5Jec Like I think a parent comment said it's hard to explain but once you get it, it's fun malable and exploratory Intellji also has a debugger that works with Clojure for when it's appropriate In php you can't redefine a function at runtime without something like runkit, in Clojure you can fix your systems at runtime
      - phyrex 5y ago
        It really isn’t and I suggest you give clojure an honest try to see why. It’s really hard to explain.
  - patrec 5y ago
    Mikel Evins has written two articles you might find interesting: https://mikelevins.github.io/posts/2020-12-18-repl-driven/ https://mikelevins.github.io/posts/2020-12-18-repl-driven/ https://mikelevins.github.io/posts/2020-02-03-programming-as-teaching/ https://mikelevins.github.io/posts/2020-02-03-programming-as...
- capableweb 5y ago
  > I understand the power of repl driven development that is difficult to explain outside the experience of it. I've been having trouble with this as well. I think we'd do best in removing "REPL" from any explainations, and instead use the words "Interactive Development", "Dynamic Development", "Hot Reload on Steroids" or something similar, as when I use terms like that, people understand it's nothing like the "repls" ("shells" really) other languages provides.
  - lispm 5y ago
    The REPL is the nucleus of interactivity in Lisp. The first Lisp, called LISP I and its successors, from John McCarthy and his team had a remarkable collection of innovative technology: * a reader for symbolic expressions. These are nested lists of symbols and other data objects like numbers and strings * a printer for symbolic expressions. * an evaluator for symbolic expressions. Each symbolic expression evaluates to a value. Side effects to the running Lisp could be added variables, data or function definitions. * an automatic garbage collector taking care of freeing no longer used memory * piece-by-piece allocation of data * a form of programming with functions, also using recursion * a way for Lisp to store and restore the main memory heap to/from external storage * Lisp compiler written in Lisp, which generates assembler, and an assembler which creates code into the runtime -> the first interactive incremental to memory compiler * a way to program with Lisp code generated by Lisp macros It had a batch REPL. This Read-Eval-Print-Loop would read a file of expressions, expression by expression, evaluate them and print each return value into a file. It used the above functions READ, EVAL and PRINT. Lisp was starting up and restoring a default image as the heap. It would then execute the file via the batch REPL and save a new, changed image as the new default image. Next time Lisp starts, it would then restore the latest image. A next step in the evolution was then to connect a terminal and let the user enter a Lisp expression. Lisp reads it, evaluates it and prints the value back. Side effects again might change the running Lisp. The REPL then waits for the next terminal input. Code could also be loaded from files. That way the REPL was not some interface which the debugger brings up on request. It was the main interface for the programmer to build up large Lisp systems piece by piece. We are talking about the early 60s here. In the coming decades the idea of a REPL morphed into extensive interactive resident development environments like Interlisp <http://interlisp.org http://interlisp.org>. Interlisp combined the REPL with managed source code, structure editing for code and data, automatic error correction of code, undo of evaluation effects, a virtual machine, ... and a lot more. Here Lisp, the IDE and the programs under development were running in one Lisp runtime. We are talking about the early 70s. Interlisp moved at Xerox PARC onto their new graphical workstations. Thus the REPL-based development environment moved to graphical user interfaces. The Interlisp team got an ACM Award for their pioneering work. The MIT AI Lab took that idea to their graphical Lisp Machines. Today in 2021 Lisp programmers often use SBCL as the implementation, GNU Emacs and SLIME (or similar) as their development environment. It's still usual to develop a running program, having potential multiple REPLs into the program, using Emacs/SLIME to send code for remote evaluation to the running Lisp. GNU Emacs itself is a Lisp program, too - with its own integrated Lisp and the development tools for it. GNU Emacs has its own REPL, called IELM, the interaction mode for Emacs Lisp. Even in Lisp not all development interactions goes through a REPL, but there are still a few very powerful ones, like those of Allegro CL, LispWorks, McCLIM, Interlisp (recently open sourced) or the Lisp Listener from Symbolics Genera. Typical is the rich interactive error handling in multilevel break loops with restarts and the ability to continue from errors. The above also support image-based development and integrate Lisp, IDE and the software under development in one program.
- throwaway894345 5y ago
  > However, working with Clojure and Scheme, I understand the power of repl driven development that is difficult to explain outside the experience of it. The only lisp I've dabbled with was Racket and I found the repl driven development to be a frustrating necessity. I would spend a lot of time trying to figure out the actual type of the thing that I a given function (even a stdlib function) needed, and futzing around in the repl seemed to be the fastest way to do it, but it was still quite slow. It reminded me a lot of my extensive experience with Python where things that are easy in, say, Go, are quite hard. People rave about their repl, but it feels like they're comparing it to a script iteration loop rather than static analysis tooling. That said, I completely buy the argument that Python's REPL is particularly bad and that there are other use cases where REPL-driven development shines. My mind is open, but these are the sorts of experiences the pro-REPL folk should be prepared to engage with in their evangelism. :)
  - ReleaseCandidat 5y ago
    > People rave about their repl, but it feels like they're comparing it to a script iteration loop rather than static analysis tooling. You do know that statically typed languages have REPLs too? Like the ML family, including Haskell. And when using something like a Jupyter notebook with a kernel for your compiled language https://github.com/gopherdata/gophernotes https://github.com/gopherdata/gophernotes you can do similar interactive programming. REPLs are about trying out ideas or changes. Lisp REPLs take that a step further, as you interact with and in your whole actually running program.
    - throwaway894345 5y ago
      > You do know that statically typed languages have REPLs too? Like the ML family, including Haskell. I do, but that I don't see how that relates to the bit of my post which you've quoted. I certainly didn't claim or imply that REPL and static type systems were mutually exclusive, only that REPLs are a poor substitute for many static analysis tasks. > And when using something like a Jupyter notebook with a kernel for your compiled language https://github.com/gopherdata/gophernotes https://github.com/gopherdata/gophernotes you can do similar interactive programming. Yeah, I'm aware. I operate a large JupyterHub cluster (among many other things) at work. :) > Lisp REPLs take that a step further, as you interact with and in your whole actually running program. That sounds nice, but it's too abstract to persuade IMHO. Personally, it seems like REPLs can make certain feedback loops a bit faster, and to that extent they seem like a modest quality of life improvement; however, considering how lisp folks positively rave about them, I assume I'm missing something.
- Qem 5y ago
  That happens with languages in the Smalltalk family too, like Pharo. It's hard to convey the convenience of the Transcript window and the while environment without actually showing ir experiencing it.
tomcam 5y ago
Modern systems are so reliant on extensive third party library support for things like database, web, network, and graphics library support I’m not sure the futureproofing argument matters.
- reikonomusha 5y ago
  I definitely think it matters. You’re right, the environment changes. It’s certainly an exercise in software engineering to modularize your application to have portable and non-portable parts. I like Lisp had treated this subject well; there are tons of libraries in Lisp that have been untouched for over a decade but still work fine.
pphysch 5y ago
"Why $lang?" Provides zero snippets of $lang, just feel-good marketing blurbs In fact, you have to scroll to the bottom of the third "read more" link to see any $lang in action. Hmm. Okay.
- avmich 5y ago
  We're talking about programming a lot on HN, and Lisp is one of more familiar things in programming, so sometimes assumptions are too high, I guess.
  - pphysch 5y ago
    > Lisp is one of more familiar things in programming Simply not true in practice. https://insights.stackoverflow.com/survey/2021#section-most-popular-technologies-programming-scripting-and-markup-languages https://insights.stackoverflow.com/survey/2021#section-most-... edit: fixed link, header was pointing at wrong section
    - Mikeb85 5y ago
      Clojure is top of that list and Common Lisp is just below Go. Not sure what your point is... Even if people don't touch Lisp they know it's that strange language with all the parentheses...
      - asdfuiopasdf 5y ago
        Clojure is no where near top, nor near go? Go 9.55% ... about a dozen entries ... Clojure 1.88% Elixir 1.74% LISP 1.33%
        Mikeb85 5y ago
        See one of my previous responses. Link was changed to highlight a different stat.
      - oblio 5y ago
qnsi 5y ago
They seem to offer open source (I think) product Nyxt browser[0]. They offer some interesting features. One is Lossless tree history, I can see it being very useful! https://nyxt.atlas.engineer/ https://nyxt.atlas.engineer/ Edit: Right now it is sponsored by EU grant! Maybe finally EU can do something useful
- ocimbote 5y ago
  I assume you think GDPR is useless?
  - trenchgun 5y ago
    No, it's actively harmful.
    - xcambar 5y ago
      I wasn't expecting this :) Care to elaborate?
      - trenchgun 5y ago
        Web usability for me has suffered a lot, and I am not aware of any benefits.
        xcambar 5y ago
        I'm fine as long as usability suffers in favor of privacy. Which is the case. Still, I'm not gonna walk away from a perspective to get both usability and privacy together. What are your opinions on the matter?
jstx1 5y ago
Is that it? Future-proof and REPL? R code from the 90s still runs today on the latest versions and everyone uses a REPL to write their code. I don't see a lot of people jumping into R any time soon, quite the opposite in fact.
- pharmakom 5y ago
  R is not trivially parsable and manipulated, since the code is not just a list. I think that’s the real magic of lisp.
  - deleted 5y ago
    [deleted]
  - asdfuiopasdf 5y ago
    Doesn't seem like it will prevent you from doing Language Oriented Programming, or advanced embedded Domain Specific Languages. Perhaps it's less ergonomic, I am not an R user. http://adv-r.had.co.nz/dsl.html http://adv-r.had.co.nz/dsl.html
  - programLyrique 5y ago
    Accessing the code part and modifying during execution is actually rather easy in R. Functions such as substitute or quote are commonly used and a language expression in R is a list that you can edit and evaluate back. The internals itself in R actually sound quite lispy: both values and codes are SEXP (S-expressions). R is inspired by Scheme and Common Lisp; it has first-class functions, multiple dispatch. https://www.stat.auckland.ac.nz/~ihaka/downloads/Interface98.pdf https://www.stat.auckland.ac.nz/~ihaka/downloads/Interface98... "This decision, more than anything else, has driven the direction that R development has taken. As noted above, there are quite strong similarities between Scheme and S, and the adoption of the S syntax for our interpreter produced something which “felt” remarkably close to S."
    - trenchgun 5y ago
      Interesting. So it could be said that R is kind of a bastard child by Lisp & APL?
tytrdev 5y ago
https://news.ycombinator.com/item?id=29166818 https://news.ycombinator.com/item?id=29166818
drmeister 5y ago
I like the term "Eternal Language" - programming languages where if you write code now - you will be able to compile and use that code ten years from now (a software lifecycle eternity). Common Lisp, C, C++, Fortran, (edit: Java) are close to eternal languages. After losing a huge amount of Python 2 code (I wasn't going to rewrite it) I implemented Clasp, a Common Lisp implementation that interoperates with C++ (https://github.com/clasp-developers/clasp.git https://github.com/clasp-developers/clasp.git) so that I can write code that will hopefully live longer. I am one of the few software developers with code that I wrote 27 years ago that is still in active use by thousands of computational chemistry researchers (Leap, a frontend for the computational chemistry molecular dynamics package AMBER, implemented in C).
- georgeecollins 5y ago
  I hope that Rust joins the pantheon of eternal languages. I feel like it has a lot of the advantages of a language like C, but is just more modern and well thought through. Also, you did not mention Java. I have very old Java code that still works fine.
  - ahohokla 5y ago
    I'd like it to be so, but i dont have faith for it. rust doesnt have a standard like lisp/c/c++ and it stands to those languages for their eternality, and at least with lisp and C their relative simplicity makes all the difference for something like that. they feel like, despite how opposite they are, discoveries rather than inventions when compared to something so complex like rust and c++
  - oblio 5y ago
    Java is probably the biggest "eternal" language we have these days. Probably tied with C and C++. There's <<so much>> Java code churned out that it's unbelievable. Business systems have a ton more code than infrastructure systems.
    - yellowapple 5y ago
      C# is also probably in a similar league, for the same reasons.
ctdonath 5y ago
Any hope of the Lisp community pulling a Swift and replacing the language with a drop-in-compatible new one built ground-up with lessons and sensibilities learned over decades?
- mtreis86 5y ago
  https://github.com/robert-strandh/SICL https://github.com/robert-strandh/SICL
  - hayley-patton 5y ago
    SICL is still an implementation of Common Lisp, and not of a new programming language (give or take some additional features, such as first-class global environments). That said, there is some overlap between the authors of SICL and the authors of Well Specified Common Lisp <https://github.com/s-expressionists/wscl https://github.com/s-expressionists/wscl>; but WSCL only really defines some undefined and contradictory behaviour in the ANSI Common Lisp specification.
    - pfdietz 5y ago
      I have become more and more convinced that unspecified behavior in a standard is a bad thing. No, giving compiler implementers room to exploit variant behaviors in the name of optimization is generally not a good idea. I understand the political reasons for it, but that doesn't make it good.
Kessler83 5y ago
To see the REPL and debugger advantages of Common Lisp over other Lisps, Python, Haskell etc., you really should try for yourself in SLIME or SLY (a SLIME fork) imo. But anyway, let's say I made an error somewhere and the program halts, putting me in the debugger. I can then examine each frame preceding the error. I can see every value going into my functions and jump around in the code generating those values. I change the code, while the debugger is still running, recompile it into the halted program and then pick a frame point right before the error occurred, to test if my changed code solves the problem. If it doesn't, I'll examine some more, perhaps start a second instance of the REPL to experiment a bit, then try another change in my code. All the while, I don't lose state. Once the problem is solved, my program will continue where it was as if the problem never happened. For something like game programming, where you may be deep in the game and have encountered some rare combination of circumstances, this is simply invaluable.
- noisy_boy 5y ago
  Having dealt with Angular dev server restarting for the tiniest code change, this sounds like a dream.
- dgan 5y ago
  Ha! Very interesting, Thanks for feedback. The number of times I restarted a game after 1 line change + recompilation..
- jonathankoren 5y ago
  REPLs are great, and I always prefer a language with one than one that doesn’t, but being able to patch a running system is Lisp’s killer feature in my opinion. I’ve never seen another language that support that. I had a bug in a long running program that would only show up after like six hours. I couldn’t replicate it in isolation because it had something to do with how state was being maintained. I set a conditional breakpoint right before the crash, inspected the stack, patch the function, and then had it pick back up by reëvaluating the current function call. Damn thing just worked. It was amazing, and saved me so much time.
  - 5y ago
idoh 5y ago
Quick question while we are all talking about lisps - any recommendations for a scheme-based web development repl? I’ve tried Racket and their framework, and while the documentation is great the one thing I really miss is that you have to do restarts every time you make an update.
- JasonFruit 5y ago
  You can use racket-mode to run a Racket REPL in Emacs, and it works the way you want. I use Emacs for all my Racket work, and it's a nice experience.
jmugan 5y ago
Lisp code I write today may run 10 years from now, but would I be able to read it a month from now? Maybe I just never got familiar enough with it, but code I wrote for my AI class was meaningless to me 6 months later.
- Jtsummers 5y ago
  That's a general problem, not a Lisp problem. Code will always be harder to read later, especially code from when someone was new to the language (I wouldn't want to read most of my grad school AI class code from 15 years ago either). But that's not unique to Lisp code. My Java, Python, C, C++, Smalltalk, SML, Scheme, Prolog code from other courses in college would almost all be pretty incomprehensible (depending on the scope of the particular project it was composed for, and how far into my academic career it was written). If you're a moderately experienced programmer and you spend more than a few weeks learning Lisp, you should be able to write code that's perfectly understandable months later.
- lispm 5y ago
  One better be able to read old code. For example the first lines of the SBCL Lisp implementation were written around 1980, when it was called Spice Lisp. The version from 1984 looks readable: http://www.softwarepreservation.org/projects/LISP/cmu/Spice_Lisp.tar.gz/view http://www.softwarepreservation.org/projects/LISP/cmu/Spice_...
- wglb 5y ago
  There are Fortran II program that I wrote decades ago that I would totally struggle to remember what was going on. I have had the same experience with C++ that I wrote years ago.
- dreamcompiler 5y ago
  It's very common for me to revisit Common Lisp code I wrote 20 years ago because it still works and I've forgotten what algorithm I used. Within a couple of minutes I have one of two reactions: "Hey that was pretty clever" or "I get how this works but this coding style is idiotic." Usually the latter. So yeah, I can glance at a Common Lisp program and tell pretty quickly what it's doing. That comes from studying 10,000 Common Lisp programs. It's pattern recognition.
timonoko 5y ago
Lisp is a linked list, where first item describes what to do with rest of list. And with infinite memory. There is also very particular textual representation of Lisp. But there could be others.
lebuffon 5y ago
I find it interesting that I can re-write this paragraph from the article and replace Lisp with Forth and it is still true. "Forth takes a far different and far more pragmatic approach. The Forth designers do not assume what syntax, features or functions will be necessary in the future. The developers of Forth give you the full powers that they had to develop the language. You can develop macros for dynamically generating code. Without going into depth about how this mechanism works, a feat that was possible in Forth was the implementation of an object oriented programming system without having to change the compiler!" It still seems to be a challenge to use programmable languages for day-to-day work despite how much fun they make programming for the programmer
- Hendrikto 5y ago
  > procedural, stack-oriented, Reverse Polish Notation Lisp sounds nicer.
  - lebuffon 5y ago
    It has merits for sure. It is higher level out of the box. Forth is low level by design for hardware level coding. However as the paragraph states, both begin at a level X but both do not stay at that level in the hands of one who understands how to use them. When used as designed, one does not program in these languages. You program in the language you create to solve the problem at hand. An example at the extreme end of this idea is CoSY (Armstrong), an APL-like language written in Forth. A small example is a useable OOP extension written in ten lines. (Paysan) My un-spoken point was that two independent language writers (McCarthy & Moore) found that similar ideas, expressed in that paragraph, implemented in radically different ways, improved their coding productivity. It begs the question is their a lesson here for programming? It could be that IRL these concepts just don't work well or that they only suite a small subset of real world problems or a small subset of human brains, but it makes me wonder...
musicale 5y ago
(because (why (not lisp)))
deleted 5y ago
[deleted]
codr7 5y ago
I attempted to answer the same question with a project after being asked again and again at work. https://github.com/codr7/whirlisp https://github.com/codr7/whirlisp
AtNightWeCode 5y ago
Repl? What modern language does not have a shell?
- finder83 5y ago
  The repl in Common Lisp is a persistent image that's actually running the program you're working on. You can inject functions, packages, change packages, debug, etc, all directly from the environment running the web server without restarting. It's more interactive development combined with hot reloading as opposed to a repl from other languages (though it does have a repl as well)
  - pfdietz 5y ago
    And you can do things like redefine classes and all the extant instances of that class (or its subclasses) automatically are updated. The general workflow is: compile and load your program and tests, run the tests, change the code and tests, recompile and reload changed files (using an internal dependency manager that is something like a make system), and continue. The focus on the repl is a bit misleading, since all the changes are off in files. I mean, you CAN type in a new function definition to the repl, but there's not much point.
lincpa 5y ago
The future belongs to "Foxpro's(TIOBE 21) Database-oriented programming paradigm is the development direction of the future programming language (2021.11.07)": https://github.com/linpengcheng/PurefunctionPipelineDataflow/blob/master/doc/Mummy4Foxpro.md https://github.com/linpengcheng/PurefunctionPipelineDataflow... The Math-based Grand Unified Programming Theory: The Pure Function Pipeline Data Flow with Principle-based Warehouse/Workshop Model https://github.com/linpengcheng/PurefunctionPipelineDataflow https://github.com/linpengcheng/PurefunctionPipelineDataflow
ibgeek 5y ago
There seem to be blog posts on "why we chose language X" nearly every week on HN and most often X tends to be a language that is not widely used. How do people manage to get any real work done using languages that do not have large and thriving communities that can build and maintain various libraries? For example, I mainly do applied ML work in bioinformatics. There really are no ecosystems that come close to those of Python and R in terms of their completeness for data science and machine learning libraries and infrastructure. I've looked at other libraries in other languages, hoping to switch, but since there are massive gaps, it's often a choice between building supporting libraries OR actually getting my work done. I'm truly surprised anyone can build much of anything complex in languages with few libraries.
- finder83 5y ago
  I feel like if you considered an average developer most people are writing API-like services that talk to a database and a few various APIs, payments, email, notification services, etc. ML is kind of a niche area where Python definitely excels and almost stands alone, but web frameworks are a dime a dozen, and every language pretty much has a postgres or mongo client. "Much of anything complex" probably wouldn't hold true for most developers...I mean, it's all complex given technology, but 99% glue code that can be written in anything. That's generally true for me at least. I have been bitten by lack of libraries for things like Cassandra in the past and switched languages because of it, but that's the exception and not the norm for me, and you really have to choose the right language for some projects. Or have some kind of architecture where you can have different parts in different languages.
- mtreis86 5y ago
  Common Lisp has libraries that are 30 years old that still work. The community seems to be (slowly) growing right now. The core language supports some fairly complex functionality out of the box. There are a number of widely used libraries that add to it with things it is missing due to age such as threading, atomics, and crypography.

271 points by susam 5y ago

Lisp is very good even if you write all your code into text files and invoke a build command before running it, which you do in a completely fresh image. If my only way of debugging were to upload the compiled image onto an embedded target and observe the effects of print statements a serial log, I would still overwhelmingly want to be using Lisp.

jmkr 5y ago

Having never used Common Lisp, it's one of the languages I wish I've used for a long time. However, working with Clojure and Scheme, I understand the power of repl driven development that is difficult to explain outside the experience of it.

threatofrain 5y ago
But repl workflows are not special to Clojure and Scheme. People in JS set breakpoints in their IDE, pause at a point in their script to interactively explore program state all the time. Is this not the same?
- gotts 5y ago
  >Is this not the same? not even close, no
- joshlemer 5y ago
  I'm also curious, I think what it comes down to is that Clojure lets you change the code of a running application, rather than reload it.
  - jimbob45 5y ago
    You can do that with C# in Visual Studio though.
    - Nihilartikel 5y ago
      The greater Clojure hot-reload super power comes from embracing the idiomatic division of state and function though. Hot reload in C# will have probably have to re-instantiate classes or restart the app. In clj, if your application state is kept in a global atom a'la (defonce app-state (atom {})) Then redefining your functions won't touch your data. The only reason to do a full restart would be if you changed the data structure expected by the functions in a way that's not semantically backwards compatible. Big-whoop on a stateless webserver, maybe, but on the front end using ClojureScript for an SPA it is nothing short of magical and has ruined any other browser dev work flow for me.
      - mikelevins 5y ago
        ...and Common Lisp and Smalltalk take it a step further. You can go ahead and change the data structure in a way that's semantically incompatible. The runtime will notice that the definition has changed and either automatically reinitialize any existing instances to conform to the new definition, or, if it doesn't know how to do that, pose a UI asking you to tell it how. And when control reaches a function that expects the old kind of object and runs into an error, it'll enter a breakloop that you can use to modify the now-out-of-date function to handle the new definition properly. Once you've redefined the function you can then tell the runtime to resume and it will proceed as if the function you called had originally had the new definition.
- mumblemumble 5y ago
  It is not quite the same. I'd argue that, while browser environments are very good, they're trying to solve a slightly different problem, and the overlap in capabilities is less than complete. Lispers sometimes say that the browser devtools experience is about halfway toward the power of a good Lisp environment, but I would argue that the converse is also true.
- hencq 5y ago
  Part of it is cultural I think. In Clojure you'll often find yourself building your app incrementally, sending individual functions to the repl from your editor. I don't think there's any reason why you couldn't do that in Javascript. Common Lisp takes this to another level though with stuff like restarts. Where the app will throw an exception during development (perhaps because a function isn't implemented yet) and instead of crashing you'll end up in the repl where you can make some fixes and keep running the app.
  - susam 5y ago
    There is a nice little story in the book Practical Common Lisp (Peter Seibel, 2005). Quoting it below: An even more impressive instance of remote debugging occurred on NASA's 1998 Deep Space 1 mission. A half year after the space craft launched, a bit of Lisp code was going to control the spacecraft for two days while conducting a sequence of experiments. Unfortunately, a subtle race condition in the code had escaped detection during ground testing and was already in space. When the bug manifested in the wild--100 million miles away from Earth--the team was able to diagnose and fix the running code, allowing the experiments to complete. One of the programmers described it as follows: Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem.
    - CodeGlitch 5y ago
      I've heard this before and it does sound like the most epic hack in the history of programming.
    - e12e 5y ago
      > 100 million miles That looks like about 9 light minutes away, so about 18 minute latency? It might be super epic, but doesn't sound super nice :)
    - Qem 5y ago
      Recently there was a bit of a fuss when people discovered the Mars Ingenuity helicopter runs python3. Now I wonder, if its software ever crashes, will people be able to just launch the python REPL and debug It?
- _peeley 5y ago
  Not really. With Clojure you don't even have to leave your editor (I use Emacs with the fantastic CIDER package). You can put your cursor over an S-expression, hit two keys, and evaluate and see the results of the S-expression directly within the text buffer. The feedback loop is so quick it's basically instant - even tabbing over to a browser or terminal window feels lethargic in comparison. I haven't used Common Lisp much, but I've seen a few really impressive demos of debugging in its available REPLs. This is a longer one, but a good tour of SLIME (also an Emacs package): https://youtu.be/_B_4vhsmRRI https://youtu.be/_B_4vhsmRRI
  - user3939382 5y ago
    In PhpStorm I hit a hotkey to set a break point, then a hotkey to make the API call to that code and immediately get an xdebug breakdown of the entire state of the program at that point. It’s almost instantaneous and I don’t have to switch windows. I would say that’s pretty close, although the upfront learning and config to get that working means it is higher overhead overall.
    - slifin 5y ago
      For context I use phpstorm and Clojure Here is a video I recorded which hopefully demonstrates just how much faster you can go in Clojure https://youtu.be/L0af0bc5Jec https://youtu.be/L0af0bc5Jec Like I think a parent comment said it's hard to explain but once you get it, it's fun malable and exploratory Intellji also has a debugger that works with Clojure for when it's appropriate In php you can't redefine a function at runtime without something like runkit, in Clojure you can fix your systems at runtime
    - phyrex 5y ago
      It really isn’t and I suggest you give clojure an honest try to see why. It’s really hard to explain.
- patrec 5y ago
  Mikel Evins has written two articles you might find interesting: https://mikelevins.github.io/posts/2020-12-18-repl-driven/ https://mikelevins.github.io/posts/2020-12-18-repl-driven/ https://mikelevins.github.io/posts/2020-02-03-programming-as-teaching/ https://mikelevins.github.io/posts/2020-02-03-programming-as...
capableweb 5y ago
> I understand the power of repl driven development that is difficult to explain outside the experience of it. I've been having trouble with this as well. I think we'd do best in removing "REPL" from any explainations, and instead use the words "Interactive Development", "Dynamic Development", "Hot Reload on Steroids" or something similar, as when I use terms like that, people understand it's nothing like the "repls" ("shells" really) other languages provides.
- lispm 5y ago
  The REPL is the nucleus of interactivity in Lisp. The first Lisp, called LISP I and its successors, from John McCarthy and his team had a remarkable collection of innovative technology: * a reader for symbolic expressions. These are nested lists of symbols and other data objects like numbers and strings * a printer for symbolic expressions. * an evaluator for symbolic expressions. Each symbolic expression evaluates to a value. Side effects to the running Lisp could be added variables, data or function definitions. * an automatic garbage collector taking care of freeing no longer used memory * piece-by-piece allocation of data * a form of programming with functions, also using recursion * a way for Lisp to store and restore the main memory heap to/from external storage * Lisp compiler written in Lisp, which generates assembler, and an assembler which creates code into the runtime -> the first interactive incremental to memory compiler * a way to program with Lisp code generated by Lisp macros It had a batch REPL. This Read-Eval-Print-Loop would read a file of expressions, expression by expression, evaluate them and print each return value into a file. It used the above functions READ, EVAL and PRINT. Lisp was starting up and restoring a default image as the heap. It would then execute the file via the batch REPL and save a new, changed image as the new default image. Next time Lisp starts, it would then restore the latest image. A next step in the evolution was then to connect a terminal and let the user enter a Lisp expression. Lisp reads it, evaluates it and prints the value back. Side effects again might change the running Lisp. The REPL then waits for the next terminal input. Code could also be loaded from files. That way the REPL was not some interface which the debugger brings up on request. It was the main interface for the programmer to build up large Lisp systems piece by piece. We are talking about the early 60s here. In the coming decades the idea of a REPL morphed into extensive interactive resident development environments like Interlisp <http://interlisp.org http://interlisp.org>. Interlisp combined the REPL with managed source code, structure editing for code and data, automatic error correction of code, undo of evaluation effects, a virtual machine, ... and a lot more. Here Lisp, the IDE and the programs under development were running in one Lisp runtime. We are talking about the early 70s. Interlisp moved at Xerox PARC onto their new graphical workstations. Thus the REPL-based development environment moved to graphical user interfaces. The Interlisp team got an ACM Award for their pioneering work. The MIT AI Lab took that idea to their graphical Lisp Machines. Today in 2021 Lisp programmers often use SBCL as the implementation, GNU Emacs and SLIME (or similar) as their development environment. It's still usual to develop a running program, having potential multiple REPLs into the program, using Emacs/SLIME to send code for remote evaluation to the running Lisp. GNU Emacs itself is a Lisp program, too - with its own integrated Lisp and the development tools for it. GNU Emacs has its own REPL, called IELM, the interaction mode for Emacs Lisp. Even in Lisp not all development interactions goes through a REPL, but there are still a few very powerful ones, like those of Allegro CL, LispWorks, McCLIM, Interlisp (recently open sourced) or the Lisp Listener from Symbolics Genera. Typical is the rich interactive error handling in multilevel break loops with restarts and the ability to continue from errors. The above also support image-based development and integrate Lisp, IDE and the software under development in one program.
throwaway894345 5y ago
> However, working with Clojure and Scheme, I understand the power of repl driven development that is difficult to explain outside the experience of it. The only lisp I've dabbled with was Racket and I found the repl driven development to be a frustrating necessity. I would spend a lot of time trying to figure out the actual type of the thing that I a given function (even a stdlib function) needed, and futzing around in the repl seemed to be the fastest way to do it, but it was still quite slow. It reminded me a lot of my extensive experience with Python where things that are easy in, say, Go, are quite hard. People rave about their repl, but it feels like they're comparing it to a script iteration loop rather than static analysis tooling. That said, I completely buy the argument that Python's REPL is particularly bad and that there are other use cases where REPL-driven development shines. My mind is open, but these are the sorts of experiences the pro-REPL folk should be prepared to engage with in their evangelism. :)
- ReleaseCandidat 5y ago
  > People rave about their repl, but it feels like they're comparing it to a script iteration loop rather than static analysis tooling. You do know that statically typed languages have REPLs too? Like the ML family, including Haskell. And when using something like a Jupyter notebook with a kernel for your compiled language https://github.com/gopherdata/gophernotes https://github.com/gopherdata/gophernotes you can do similar interactive programming. REPLs are about trying out ideas or changes. Lisp REPLs take that a step further, as you interact with and in your whole actually running program.
  - throwaway894345 5y ago
    > You do know that statically typed languages have REPLs too? Like the ML family, including Haskell. I do, but that I don't see how that relates to the bit of my post which you've quoted. I certainly didn't claim or imply that REPL and static type systems were mutually exclusive, only that REPLs are a poor substitute for many static analysis tasks. > And when using something like a Jupyter notebook with a kernel for your compiled language https://github.com/gopherdata/gophernotes https://github.com/gopherdata/gophernotes you can do similar interactive programming. Yeah, I'm aware. I operate a large JupyterHub cluster (among many other things) at work. :) > Lisp REPLs take that a step further, as you interact with and in your whole actually running program. That sounds nice, but it's too abstract to persuade IMHO. Personally, it seems like REPLs can make certain feedback loops a bit faster, and to that extent they seem like a modest quality of life improvement; however, considering how lisp folks positively rave about them, I assume I'm missing something.
Qem 5y ago
That happens with languages in the Smalltalk family too, like Pharo. It's hard to convey the convenience of the Transcript window and the while environment without actually showing ir experiencing it.

tomcam 5y ago

Modern systems are so reliant on extensive third party library support for things like database, web, network, and graphics library support I’m not sure the futureproofing argument matters.

reikonomusha 5y ago
I definitely think it matters. You’re right, the environment changes. It’s certainly an exercise in software engineering to modularize your application to have portable and non-portable parts. I like Lisp had treated this subject well; there are tons of libraries in Lisp that have been untouched for over a decade but still work fine.

pphysch 5y ago

"Why $lang?" Provides zero snippets of $lang, just feel-good marketing blurbs In fact, you have to scroll to the bottom of the third "read more" link to see any $lang in action. Hmm. Okay.

avmich 5y ago
We're talking about programming a lot on HN, and Lisp is one of more familiar things in programming, so sometimes assumptions are too high, I guess.
- pphysch 5y ago
  > Lisp is one of more familiar things in programming Simply not true in practice. https://insights.stackoverflow.com/survey/2021#section-most-popular-technologies-programming-scripting-and-markup-languages https://insights.stackoverflow.com/survey/2021#section-most-... edit: fixed link, header was pointing at wrong section
  - Mikeb85 5y ago
    Clojure is top of that list and Common Lisp is just below Go. Not sure what your point is... Even if people don't touch Lisp they know it's that strange language with all the parentheses...
    - asdfuiopasdf 5y ago
      Clojure is no where near top, nor near go? Go 9.55% ... about a dozen entries ... Clojure 1.88% Elixir 1.74% LISP 1.33%
      - Mikeb85 5y ago
        See one of my previous responses. Link was changed to highlight a different stat.
    - oblio 5y ago

qnsi 5y ago

They seem to offer open source (I think) product Nyxt browser[0]. They offer some interesting features. One is Lossless tree history, I can see it being very useful! https://nyxt.atlas.engineer/ https://nyxt.atlas.engineer/ Edit: Right now it is sponsored by EU grant! Maybe finally EU can do something useful

ocimbote 5y ago
I assume you think GDPR is useless?
- trenchgun 5y ago
  No, it's actively harmful.
  - xcambar 5y ago
    I wasn't expecting this :) Care to elaborate?
    - trenchgun 5y ago
      Web usability for me has suffered a lot, and I am not aware of any benefits.
      - xcambar 5y ago
        I'm fine as long as usability suffers in favor of privacy. Which is the case. Still, I'm not gonna walk away from a perspective to get both usability and privacy together. What are your opinions on the matter?

jstx1 5y ago

Is that it? Future-proof and REPL? R code from the 90s still runs today on the latest versions and everyone uses a REPL to write their code. I don't see a lot of people jumping into R any time soon, quite the opposite in fact.

pharmakom 5y ago
R is not trivially parsable and manipulated, since the code is not just a list. I think that’s the real magic of lisp.
- deleted 5y ago
  [deleted]
- asdfuiopasdf 5y ago
  Doesn't seem like it will prevent you from doing Language Oriented Programming, or advanced embedded Domain Specific Languages. Perhaps it's less ergonomic, I am not an R user. http://adv-r.had.co.nz/dsl.html http://adv-r.had.co.nz/dsl.html
- programLyrique 5y ago
  Accessing the code part and modifying during execution is actually rather easy in R. Functions such as substitute or quote are commonly used and a language expression in R is a list that you can edit and evaluate back. The internals itself in R actually sound quite lispy: both values and codes are SEXP (S-expressions). R is inspired by Scheme and Common Lisp; it has first-class functions, multiple dispatch. https://www.stat.auckland.ac.nz/~ihaka/downloads/Interface98.pdf https://www.stat.auckland.ac.nz/~ihaka/downloads/Interface98... "This decision, more than anything else, has driven the direction that R development has taken. As noted above, there are quite strong similarities between Scheme and S, and the adoption of the S syntax for our interpreter produced something which “felt” remarkably close to S."
  - trenchgun 5y ago
    Interesting. So it could be said that R is kind of a bastard child by Lisp & APL?

tytrdev 5y ago

https://news.ycombinator.com/item?id=29166818 https://news.ycombinator.com/item?id=29166818

drmeister 5y ago

I like the term "Eternal Language" - programming languages where if you write code now - you will be able to compile and use that code ten years from now (a software lifecycle eternity). Common Lisp, C, C++, Fortran, (edit: Java) are close to eternal languages. After losing a huge amount of Python 2 code (I wasn't going to rewrite it) I implemented Clasp, a Common Lisp implementation that interoperates with C++ (https://github.com/clasp-developers/clasp.git https://github.com/clasp-developers/clasp.git) so that I can write code that will hopefully live longer. I am one of the few software developers with code that I wrote 27 years ago that is still in active use by thousands of computational chemistry researchers (Leap, a frontend for the computational chemistry molecular dynamics package AMBER, implemented in C).

georgeecollins 5y ago
I hope that Rust joins the pantheon of eternal languages. I feel like it has a lot of the advantages of a language like C, but is just more modern and well thought through. Also, you did not mention Java. I have very old Java code that still works fine.
- ahohokla 5y ago
  I'd like it to be so, but i dont have faith for it. rust doesnt have a standard like lisp/c/c++ and it stands to those languages for their eternality, and at least with lisp and C their relative simplicity makes all the difference for something like that. they feel like, despite how opposite they are, discoveries rather than inventions when compared to something so complex like rust and c++
- oblio 5y ago
  Java is probably the biggest "eternal" language we have these days. Probably tied with C and C++. There's <<so much>> Java code churned out that it's unbelievable. Business systems have a ton more code than infrastructure systems.
  - yellowapple 5y ago
    C# is also probably in a similar league, for the same reasons.

ctdonath 5y ago

Any hope of the Lisp community pulling a Swift and replacing the language with a drop-in-compatible new one built ground-up with lessons and sensibilities learned over decades?

mtreis86 5y ago
https://github.com/robert-strandh/SICL https://github.com/robert-strandh/SICL
- hayley-patton 5y ago
  SICL is still an implementation of Common Lisp, and not of a new programming language (give or take some additional features, such as first-class global environments). That said, there is some overlap between the authors of SICL and the authors of Well Specified Common Lisp <https://github.com/s-expressionists/wscl https://github.com/s-expressionists/wscl>; but WSCL only really defines some undefined and contradictory behaviour in the ANSI Common Lisp specification.
  - pfdietz 5y ago
    I have become more and more convinced that unspecified behavior in a standard is a bad thing. No, giving compiler implementers room to exploit variant behaviors in the name of optimization is generally not a good idea. I understand the political reasons for it, but that doesn't make it good.

Kessler83 5y ago

To see the REPL and debugger advantages of Common Lisp over other Lisps, Python, Haskell etc., you really should try for yourself in SLIME or SLY (a SLIME fork) imo. But anyway, let's say I made an error somewhere and the program halts, putting me in the debugger. I can then examine each frame preceding the error. I can see every value going into my functions and jump around in the code generating those values. I change the code, while the debugger is still running, recompile it into the halted program and then pick a frame point right before the error occurred, to test if my changed code solves the problem. If it doesn't, I'll examine some more, perhaps start a second instance of the REPL to experiment a bit, then try another change in my code. All the while, I don't lose state. Once the problem is solved, my program will continue where it was as if the problem never happened. For something like game programming, where you may be deep in the game and have encountered some rare combination of circumstances, this is simply invaluable.

noisy_boy 5y ago
Having dealt with Angular dev server restarting for the tiniest code change, this sounds like a dream.
dgan 5y ago
Ha! Very interesting, Thanks for feedback. The number of times I restarted a game after 1 line change + recompilation..
jonathankoren 5y ago
REPLs are great, and I always prefer a language with one than one that doesn’t, but being able to patch a running system is Lisp’s killer feature in my opinion. I’ve never seen another language that support that. I had a bug in a long running program that would only show up after like six hours. I couldn’t replicate it in isolation because it had something to do with how state was being maintained. I set a conditional breakpoint right before the crash, inspected the stack, patch the function, and then had it pick back up by reëvaluating the current function call. Damn thing just worked. It was amazing, and saved me so much time.
- 5y ago

idoh 5y ago

Quick question while we are all talking about lisps - any recommendations for a scheme-based web development repl? I’ve tried Racket and their framework, and while the documentation is great the one thing I really miss is that you have to do restarts every time you make an update.

JasonFruit 5y ago
You can use racket-mode to run a Racket REPL in Emacs, and it works the way you want. I use Emacs for all my Racket work, and it's a nice experience.

jmugan 5y ago

Lisp code I write today may run 10 years from now, but would I be able to read it a month from now? Maybe I just never got familiar enough with it, but code I wrote for my AI class was meaningless to me 6 months later.

Jtsummers 5y ago
That's a general problem, not a Lisp problem. Code will always be harder to read later, especially code from when someone was new to the language (I wouldn't want to read most of my grad school AI class code from 15 years ago either). But that's not unique to Lisp code. My Java, Python, C, C++, Smalltalk, SML, Scheme, Prolog code from other courses in college would almost all be pretty incomprehensible (depending on the scope of the particular project it was composed for, and how far into my academic career it was written). If you're a moderately experienced programmer and you spend more than a few weeks learning Lisp, you should be able to write code that's perfectly understandable months later.
lispm 5y ago
One better be able to read old code. For example the first lines of the SBCL Lisp implementation were written around 1980, when it was called Spice Lisp. The version from 1984 looks readable: http://www.softwarepreservation.org/projects/LISP/cmu/Spice_Lisp.tar.gz/view http://www.softwarepreservation.org/projects/LISP/cmu/Spice_...
wglb 5y ago
There are Fortran II program that I wrote decades ago that I would totally struggle to remember what was going on. I have had the same experience with C++ that I wrote years ago.
dreamcompiler 5y ago
It's very common for me to revisit Common Lisp code I wrote 20 years ago because it still works and I've forgotten what algorithm I used. Within a couple of minutes I have one of two reactions: "Hey that was pretty clever" or "I get how this works but this coding style is idiotic." Usually the latter. So yeah, I can glance at a Common Lisp program and tell pretty quickly what it's doing. That comes from studying 10,000 Common Lisp programs. It's pattern recognition.

timonoko 5y ago

Lisp is a linked list, where first item describes what to do with rest of list. And with infinite memory. There is also very particular textual representation of Lisp. But there could be others.

lebuffon 5y ago

I find it interesting that I can re-write this paragraph from the article and replace Lisp with Forth and it is still true. "Forth takes a far different and far more pragmatic approach. The Forth designers do not assume what syntax, features or functions will be necessary in the future. The developers of Forth give you the full powers that they had to develop the language. You can develop macros for dynamically generating code. Without going into depth about how this mechanism works, a feat that was possible in Forth was the implementation of an object oriented programming system without having to change the compiler!" It still seems to be a challenge to use programmable languages for day-to-day work despite how much fun they make programming for the programmer

Hendrikto 5y ago
> procedural, stack-oriented, Reverse Polish Notation Lisp sounds nicer.
- lebuffon 5y ago
  It has merits for sure. It is higher level out of the box. Forth is low level by design for hardware level coding. However as the paragraph states, both begin at a level X but both do not stay at that level in the hands of one who understands how to use them. When used as designed, one does not program in these languages. You program in the language you create to solve the problem at hand. An example at the extreme end of this idea is CoSY (Armstrong), an APL-like language written in Forth. A small example is a useable OOP extension written in ten lines. (Paysan) My un-spoken point was that two independent language writers (McCarthy & Moore) found that similar ideas, expressed in that paragraph, implemented in radically different ways, improved their coding productivity. It begs the question is their a lesson here for programming? It could be that IRL these concepts just don't work well or that they only suite a small subset of real world problems or a small subset of human brains, but it makes me wonder...

musicale 5y ago

(because (why (not lisp)))

deleted 5y ago

[deleted]

codr7 5y ago

I attempted to answer the same question with a project after being asked again and again at work. https://github.com/codr7/whirlisp https://github.com/codr7/whirlisp

AtNightWeCode 5y ago

Repl? What modern language does not have a shell?

finder83 5y ago
The repl in Common Lisp is a persistent image that's actually running the program you're working on. You can inject functions, packages, change packages, debug, etc, all directly from the environment running the web server without restarting. It's more interactive development combined with hot reloading as opposed to a repl from other languages (though it does have a repl as well)
- pfdietz 5y ago
  And you can do things like redefine classes and all the extant instances of that class (or its subclasses) automatically are updated. The general workflow is: compile and load your program and tests, run the tests, change the code and tests, recompile and reload changed files (using an internal dependency manager that is something like a make system), and continue. The focus on the repl is a bit misleading, since all the changes are off in files. I mean, you CAN type in a new function definition to the repl, but there's not much point.

lincpa 5y ago

The future belongs to "Foxpro's(TIOBE 21) Database-oriented programming paradigm is the development direction of the future programming language (2021.11.07)": https://github.com/linpengcheng/PurefunctionPipelineDataflow/blob/master/doc/Mummy4Foxpro.md https://github.com/linpengcheng/PurefunctionPipelineDataflow... The Math-based Grand Unified Programming Theory: The Pure Function Pipeline Data Flow with Principle-based Warehouse/Workshop Model https://github.com/linpengcheng/PurefunctionPipelineDataflow https://github.com/linpengcheng/PurefunctionPipelineDataflow

ibgeek 5y ago

There seem to be blog posts on "why we chose language X" nearly every week on HN and most often X tends to be a language that is not widely used. How do people manage to get any real work done using languages that do not have large and thriving communities that can build and maintain various libraries? For example, I mainly do applied ML work in bioinformatics. There really are no ecosystems that come close to those of Python and R in terms of their completeness for data science and machine learning libraries and infrastructure. I've looked at other libraries in other languages, hoping to switch, but since there are massive gaps, it's often a choice between building supporting libraries OR actually getting my work done. I'm truly surprised anyone can build much of anything complex in languages with few libraries.

finder83 5y ago
I feel like if you considered an average developer most people are writing API-like services that talk to a database and a few various APIs, payments, email, notification services, etc. ML is kind of a niche area where Python definitely excels and almost stands alone, but web frameworks are a dime a dozen, and every language pretty much has a postgres or mongo client. "Much of anything complex" probably wouldn't hold true for most developers...I mean, it's all complex given technology, but 99% glue code that can be written in anything. That's generally true for me at least. I have been bitten by lack of libraries for things like Cassandra in the past and switched languages because of it, but that's the exception and not the norm for me, and you really have to choose the right language for some projects. Or have some kind of architecture where you can have different parts in different languages.
mtreis86 5y ago
Common Lisp has libraries that are 30 years old that still work. The community seems to be (slowly) growing right now. The core language supports some fairly complex functionality out of the box. There are a number of widely used libraries that add to it with things it is missing due to age such as threading, atomics, and crypography.