acl2

Is that something you had heard or guessed? Did you attend a Lisp conference and talked to the people, where they were coming from (companies, universities, research labs, ...) and in what domain they were working on? Let's say, ACL2, a theorem prover written in Common Lisp. Unless what Mr. Urban tells you about Lisp users, they have a github repository. They have user/developer meetings. They even presented their stuff at Lisp conferences (I have attended one myself, where I saw a talk about it), wrote books about it, published hundreds of research reports, ... The user group shares > one million lines of Lisp code ( https://github.com/acl2/acl2/tree/master/books ), with many more lines of code developed by users. https://github.com/acl2/acl2/ Workshops: https://www.cs.utexas.edu/users/moore/acl2/workshops.html How does that fit into you

Some pointers: Scorecloud (https://scorecloud.com/), a music composition software (you sing, it writes music) comes from research, and is built in Common Lisp. pgloader was rewritten from Python to Lisp: https://tapoueh.org/blog/2014/05/why-is-pgloader-so-much-fas... because of Python's poor performances and threading capacities. A theorem prover used in the industry: https://github.com/acl2/acl2 A Lisp vendor selling semantic graph solutions: https://franz.com/ (see also its success stories for industry examples) Here's a sadder story: a team switched from CL to Go for production, but still use CL for prototyping: https://lisp-journey.gitlab.io/blog/pro-mailing-list-on-comm... Some use CL in bioinformatics (and claim it's the best tool for the job). For example, they create a new Lisp implementation: https://github.com/clasp-developers/c

> I'd bet that that C, C++, Java or even Python has a numbers advantage by one or two orders of magnitude. That's a numeric argument, not a qualitative. Common Lisp is not popular in the mass market, but not because one can't easily write large applications. Something like Common Lisp actually was designed for the development of large and complex applications. If you develop a large C application, you could shrink by porting it to Lisp. Lisp's code density in larger applications is much higher than C and large C applications tend to reimplement half of what Common Lisp brings out of the box (objects, code loading, runtime scripting, automatic memory management, error handling, ...) - see Java. There are systems written in Common Lisp which are much larger than 1MLoc. Some applications like Macsyma easily reached already >100kloc in the 80

If you feel the need to contribute code, then there is Quicklisp to distribute it. > Not as much as they should, which is the whole point of the article, and a core lesson of history. One of the uses of Lisp is prototyping. The Interface Builder from NeXT/Apple was originally written in Lisp. The Dylan IDE was a prototype in Lisp. There is lots of research code, some never meant to made available as a supported library/application. Maybe somebody writes a theorem prover in Lisp for his/her PhD. The chance for finding users is slim - there are already a few others. But if you wanted to share, check out the ACL2 (A Computational Logic for Applicative Common Lisp), it comes with lots of shared code: http://www.cs.utexas.edu/users/moore/acl2/current/combined-m... https://github.com/acl2/acl2/tree/master/books ACL2 is shared and maintained. I

If you use microprocessors from companies like AMD and Intel, there is a good chance that parts of their design were checked with large amounts of Lisp code. Example: https://github.com/acl2/acl2/tree/master/books/rtl/rel11 > This directory contains an ACL2 library of register-transfer logic, developed at AMD from 1995 to 2011, and at Intel from 2012 to the present, in support of the mechanical verification of the floating-point arithmetic units designed during those periods by the respective companies.

If DARPA succeeds in this, it will be a HUGE advantage for everyone. The way I personally see this happening is everything has to be formally verified. This will guarantee that the file written tomorrow will be successfully read by yesterday's programs, and that contemporary software is compatible with future OSes. (Does this mean that we freeze libc?) But there is a problem: there are a lot of quirks for hardware in modern OS/drivers, which add weird and possibly unreliable code. Does the hardware+firmware has to be formally verified too? Do we have to run our software on all hardware that exists, e.g. starting from 6502 and until some future CPU? Do we want to use POSIX? Subset of POSIX? cough Plan9? cough Another problem I see is seemingly inevitable software bloating over time. - What features do we have to include in our OS, our