4 ms·

> Lisp is the most expressive and flexible language. You can reach a flow-state where ideas can freely flow from your mind into code This kind of claim typical

> Lisp is the most expressive and flexible language. You can reach a flow-state where ideas can freely flow from your mind into code This kind of claim typically comes from someone pretty new to the world of software development. You can say this of any language, really, and any developer who's reasonably proficient in language X will also claim that with X, their ideas flow directly into code. > The Lisp programming language Racket is used to teach programming fundamentals in modern Computer Science courses. Unsurprising cherry picking. How many universities teach Racket compared to, Javascript C/C++, or Java? The rest of the article is of the same cloth, raving about Lisp and Clojure as the best programming languages ever invented. You should learn Lisp, no matter what kind of developer you are. But by today's standards, Lisp a pretty antiquated language which still hasn't caught up to modern trends (static types, asynchronism, etc...) and with a very poor tooling (lack of IDE's) and library ecosystem (building websites, parallelism, GUI, etc...).

Jach 5y ago
> You should learn Lisp, no matter what kind of developer you are. But by today's standards, Lisp a pretty antiquated language which still hasn't caught up to modern trends (static types, asynchronism, etc...) and with a very poor tooling (lack of IDE's) and library ecosystem (building websites, parallelism, GUI, etc...). Literally all of these things are present in Common Lisp (ok the static types "full experience" leads you to something like Coalton: https://github.com/coalton-lang/coalton https://github.com/coalton-lang/coalton however the plain SBCL experience does have some compile-time type checking). Meanwhile many so-called modern languages still lack Lisp's incremental compilation let alone the full interactive development experience such a feature can help support, an OOP system as flexible as CLOS, they can't gracefully manipulate their own code as data, they don't have anything like the condition system...
newplagiarist 5y ago
> which still hasn't caught up to modern trends (static types, asynchronism, etc...) Ignoring the fact that your modern trends aren't modern. I don't think any of these statements really are true for Lisp as a family of languages: For example Racket has typed Racket. https://docs.racket-lang.org/ts-guide/ https://docs.racket-lang.org/ts-guide/ For asynchronicity Clojure has clojure.async https://github.com/clojure/core.async https://github.com/clojure/core.async > and with a very poor tooling (lack of IDE's) Lisps have fantastic support in Emacs and VSCode and are in general simple enough languages that often the heavyweight of an IDE is not needed. But if you want IDEs there are: Dr. Racket - https://docs.racket-lang.org/drracket/index.html https://docs.racket-lang.org/drracket/index.html Cursive - https://cursive-ide.com/ https://cursive-ide.com/ Emacs/Cider - https://docs.cider.mx/cider/index.html https://docs.cider.mx/cider/index.html > and library ecosystem (building websites, parallelism, GUI, etc...) Websites - Reagent, a ClojureScript wrapper for React https://github.com/reagent-project/reagent https://github.com/reagent-project/reagent GUIs - Clojure has the entirety of Java to steal GUIs from - Ex: https://github.com/cljfx/cljfx https://github.com/cljfx/cljfx Just because the Lisp family is old and has a simple syntax does not mean it's an antiquated language or that there are not new developments going on there.
dragonwriter 5y ago
> But by today's standards, Lisp a pretty antiquated language which still hasn't caught up to modern trends (static types, Typed Racket exists, as does syntactic support for static type declarations in Common Lisp (though whether implementations do anything with declarations is up to them; some, however, do offer compile-time checking.) > asynchronism, Racket has asynchronisn via both the thread API (which aren't OS thread, but asynchronous tasks with mailboxes) and via promises (promise/force in Racket is pretty much all the good parts of async/await without the bad parts; future/touch provides a similar API for operations that are parallel rather than merely asynchronous.) > very poor tooling (lack of IDE's) Racket, CL, and Clojure all have dedicated IDEs; a number of Java-focused IDEs support Clojure as well. > library ecosystem (building websites, parallelism, GUI, etc...) Clojure is designed to leverage the JVM ecosystem, so that's clearly not the case for Clojure unless your standard for a library ecosystem is something beyond what the Java world has. (Similarly with ClojureScript and JS.) But, sure, there's no Lisp-first platform as popular as the JVM, .NET, JS, or CPython.
didibus 5y ago
> Lisp a pretty antiquated language which still hasn't caught up to modern trends (static types, asynchronism, etc...) and with a very poor tooling (lack of IDE's) and library ecosystem (building websites, parallelism, GUI, etc...) That's pretty much the whole point of Clojure, a modern Lisp, built for concurrent and asynchronous programming, targeting modern platforms like the JVM, CLR, NodeJS, browser JS runtimes, with great IDE and tooling, and access to the largest swath of existing libraries from various ecosystems. It also has an optional static type checker, though it isn't very popular and so you'll lose type checks at the boundary between your app and all libraries you use (even most of the standard lib). But I wouldn't really call static types a "modern trend" in any way, considering we just had untyped languages overthrow static ones in popularity with the unprecedented rise of Python, Ruby and JavaScript. And the most popular typed languages are still playing catch up to the ML languages of yore in their static type checking capabilities.
- c-cube 5y ago
  The untyped languages rose in popularity in the 2000s and got as mainstream as it gets. But static typing is having a comeback in the past 5-10 years, with go, rust, kotlin, and of course typescript. Almost every dynamic language is getting some flavor of gradual typing and most people seem to love it.
  - didibus 5y ago
    I guess it depends what your mesure criteria are. Based on this video: https://www.youtube.com/watch?v=UNSoPa-XQN0 https://www.youtube.com/watch?v=UNSoPa-XQN0 JS and Python took the top spot only in the last 5 years, and I'd think they're only continuing to attract more people. There's been some new typed language also gaining traction, just not as much or as quickly. Frankly it doesn't seem types or not matter much over the years for popularity. What I find interesting personally now is that a lot of people come out of school learning Python, an untyped language. I wonder what effect that'll have long term, where as before I feel it was either Java or C++ or another flavor of a typed language that university and schools would teach.
    - 5y ago
agumonkey 5y ago
I wonder if I other proglangs are really on par Lisp like (open to extension at the meta level) langs. It's true a good perlist or ada coder can flow. But when you reach the limit of a language, you're stuck. These other languages become their own tool, and compound on.
rmbyrro 5y ago
> This kind of claim typically comes from someone pretty new to the world of software development. Have you ever seen a newbie talking about Clojure? I bet ~98.5% of developers < 5 years experience never heard of it. Let alone claim how good it is.

Jach 5y ago

> You should learn Lisp, no matter what kind of developer you are. But by today's standards, Lisp a pretty antiquated language which still hasn't caught up to modern trends (static types, asynchronism, etc...) and with a very poor tooling (lack of IDE's) and library ecosystem (building websites, parallelism, GUI, etc...). Literally all of these things are present in Common Lisp (ok the static types "full experience" leads you to something like Coalton: https://github.com/coalton-lang/coalton https://github.com/coalton-lang/coalton however the plain SBCL experience does have some compile-time type checking). Meanwhile many so-called modern languages still lack Lisp's incremental compilation let alone the full interactive development experience such a feature can help support, an OOP system as flexible as CLOS, they can't gracefully manipulate their own code as data, they don't have anything like the condition system...

newplagiarist 5y ago

> which still hasn't caught up to modern trends (static types, asynchronism, etc...) Ignoring the fact that your modern trends aren't modern. I don't think any of these statements really are true for Lisp as a family of languages: For example Racket has typed Racket. https://docs.racket-lang.org/ts-guide/ https://docs.racket-lang.org/ts-guide/ For asynchronicity Clojure has clojure.async https://github.com/clojure/core.async https://github.com/clojure/core.async > and with a very poor tooling (lack of IDE's) Lisps have fantastic support in Emacs and VSCode and are in general simple enough languages that often the heavyweight of an IDE is not needed. But if you want IDEs there are: Dr. Racket - https://docs.racket-lang.org/drracket/index.html https://docs.racket-lang.org/drracket/index.html Cursive - https://cursive-ide.com/ https://cursive-ide.com/ Emacs/Cider - https://docs.cider.mx/cider/index.html https://docs.cider.mx/cider/index.html > and library ecosystem (building websites, parallelism, GUI, etc...) Websites - Reagent, a ClojureScript wrapper for React https://github.com/reagent-project/reagent https://github.com/reagent-project/reagent GUIs - Clojure has the entirety of Java to steal GUIs from - Ex: https://github.com/cljfx/cljfx https://github.com/cljfx/cljfx Just because the Lisp family is old and has a simple syntax does not mean it's an antiquated language or that there are not new developments going on there.

dragonwriter 5y ago

> But by today's standards, Lisp a pretty antiquated language which still hasn't caught up to modern trends (static types, Typed Racket exists, as does syntactic support for static type declarations in Common Lisp (though whether implementations do anything with declarations is up to them; some, however, do offer compile-time checking.) > asynchronism, Racket has asynchronisn via both the thread API (which aren't OS thread, but asynchronous tasks with mailboxes) and via promises (promise/force in Racket is pretty much all the good parts of async/await without the bad parts; future/touch provides a similar API for operations that are parallel rather than merely asynchronous.) > very poor tooling (lack of IDE's) Racket, CL, and Clojure all have dedicated IDEs; a number of Java-focused IDEs support Clojure as well. > library ecosystem (building websites, parallelism, GUI, etc...) Clojure is designed to leverage the JVM ecosystem, so that's clearly not the case for Clojure unless your standard for a library ecosystem is something beyond what the Java world has. (Similarly with ClojureScript and JS.) But, sure, there's no Lisp-first platform as popular as the JVM, .NET, JS, or CPython.

didibus 5y ago

> Lisp a pretty antiquated language which still hasn't caught up to modern trends (static types, asynchronism, etc...) and with a very poor tooling (lack of IDE's) and library ecosystem (building websites, parallelism, GUI, etc...) That's pretty much the whole point of Clojure, a modern Lisp, built for concurrent and asynchronous programming, targeting modern platforms like the JVM, CLR, NodeJS, browser JS runtimes, with great IDE and tooling, and access to the largest swath of existing libraries from various ecosystems. It also has an optional static type checker, though it isn't very popular and so you'll lose type checks at the boundary between your app and all libraries you use (even most of the standard lib). But I wouldn't really call static types a "modern trend" in any way, considering we just had untyped languages overthrow static ones in popularity with the unprecedented rise of Python, Ruby and JavaScript. And the most popular typed languages are still playing catch up to the ML languages of yore in their static type checking capabilities.

c-cube 5y ago
The untyped languages rose in popularity in the 2000s and got as mainstream as it gets. But static typing is having a comeback in the past 5-10 years, with go, rust, kotlin, and of course typescript. Almost every dynamic language is getting some flavor of gradual typing and most people seem to love it.
- didibus 5y ago
  I guess it depends what your mesure criteria are. Based on this video: https://www.youtube.com/watch?v=UNSoPa-XQN0 https://www.youtube.com/watch?v=UNSoPa-XQN0 JS and Python took the top spot only in the last 5 years, and I'd think they're only continuing to attract more people. There's been some new typed language also gaining traction, just not as much or as quickly. Frankly it doesn't seem types or not matter much over the years for popularity. What I find interesting personally now is that a lot of people come out of school learning Python, an untyped language. I wonder what effect that'll have long term, where as before I feel it was either Java or C++ or another flavor of a typed language that university and schools would teach.
  - 5y ago

agumonkey 5y ago

I wonder if I other proglangs are really on par Lisp like (open to extension at the meta level) langs. It's true a good perlist or ada coder can flow. But when you reach the limit of a language, you're stuck. These other languages become their own tool, and compound on.

rmbyrro 5y ago

> This kind of claim typically comes from someone pretty new to the world of software development. Have you ever seen a newbie talking about Clojure? I bet ~98.5% of developers < 5 years experience never heard of it. Let alone claim how good it is.