Warning: this is a rant.
Warning: you have been warned.
Note: actually worthwhile content starts in the second subsection. You are free to skip the first one.
I don't know Julia!
I saw devs leaving CL for a new graal (and eventually coming back). Grass may not be greener on the other side…
You can't make it a CLI script, because it compiles the whole code WITH dependencies every time, and as soon as you import some serious libraries, compile times will skyrocket. I quickly hit 40 seconds of compilation with just geospatial lib and dataframes. These 40 seconds turned out to be A LOT when you develop interactively. And you can't build everything in a Jupyter Notebook, because eventually you'll have to switch to a CLI script.
(ql:quickload :fset) | |
(defun get-dependencies (system) | |
"Returns a set with all dependencies of a given system. | |
System should be loaded first." | |
(labels ((normalize (name) | |
(etypecase name | |
(string (string-downcase name)) | |
(symbol (normalize (symbol-name name))) | |
(list |
I'll preface this with three things. 1. I prefer schemes over Common Lisps, and I prefer Racket of the Schemes. 2. There is more to it than the points I raise here. 3. I assume you have no previous experience with Lisp, and don't have a preference for Schemes over Common Lisp. With all that out of the way... I would say Common Lisp/SBCL. Let me explain
Now as to why Common Lisp over Scheme
Testimonies
The thing in CL I miss most doing Clojure as my day job? CL's compiler. I like having a compiler tell me at compile time about the mistakes I've made. Bogus arguments. Unreachable code because of unhandled exceptions, and so on. CL saves me round after round of bugs that in clojure aren't found until you run the code. If you test well, it's found when testing, if you don't it's found in production. "Clojure compiler" almost demands air quotes.
CL's optional but oh-so-useful model of type declarations is also infinitely more useful (to me) than Clojure's use of "spec", and instrumentation that happens only at test time because of the cost. Depending on the OPTIMIZE declarations, other type defs are a floor wax and dessert topping. Want checks for argument types? Lower optimizations. Want most efficient machine code? High optimizations.
/u/Decweb, March 2023 https://www.reddit.com/r/lisp/comments/11ttnxk/the_rise_fall_of_lisp_too_good_for_the_rest_of/jczpysp/
; John McCarthy. Puzzle Solving Program in LISP. Memo 20, Artificial Intelligence Project | |
; http://www.bitsavers.org/pdf/mit/ai/aim/AIM-020.pdf | |
; 1960 | |
; Common Lisp translation: Rainer Joswig, 2016, joswig@lisp.de | |
; basically the code is unchanged, but using s-expression syntax in Common Lisp | |
(defparameter pzl | |
'((a1 (a2 a5) 7.5) | |
(a2 (a1 a5 a9 a3) 3.5) |
Fonte: https://www.maccanismi.it/2012/08/21/elenco-url-streaming-radio-italiane-sul-web-rtl-rds-radio-kiss-kiss-r101-virgin-radio-e-moltre-altre/ | |
Da usare per lettori come VLC e similari. | |
RTL: | |
http://shoutcast.rtl.it:3010/ | |
RTL Best: | |
http://shoutcast.rtl.it:3020/ | |
RTL ItalianStyle: |
;; | |
;; scheme coin - a common lisp blockchain | |
;; | |
;; Burton Samograd | |
;; 2017 | |
(load "~/quicklisp/setup.lisp") | |
(defconstant *coin-name* "Scheme Coin") |
This article is a response to mfiano’s From Common Lisp to Julia which might also convey some developments happening in Common Lisp. I do not intend to suggest that someone coming from a Matlab, R, or Python background should pickup Common Lisp. Julia is a reasonably good language when compared to what it intends to replace. You should pickup Common Lisp only if you are interested in programming in general, not limited to scientific computing, and envision yourself writing code for the rest of your life. It will expand your mind to what is possible, and that goes beyond the macro system. Along the same lines though, you should also pickup C, Haskell, Forth, and perhaps a few other languages that have some noteworthy things to teach, and that I too have been to lazy to learn.
/I also do not intend to offend anyone. I’m okay with criticizing Common Lisp (I myself have done it below!), but I want t