2,130 karma · joined June 6, 2008
Also https://github.com/robert-strandh/McCLIM looks maintained but if it's anything like what it was a couple of years when I last looked at it, it could use some contributors :)
There are also at least 3 GTK+ bindings that I've seen around.
http://cliki.net/GUI lists 31 GUI libraries. We have enough for every day of the month :)
We've had a string of really cool lisp projects this year, web frameworks, implementations, web servers, libraries, etc. Couple that with Edi Weitz's upcoming book, it's as exiting to be a lisper now as ever. Hack gloriously and eat your parenthesis for breakfast my lispy friends :)
Obviously mobile looks like an area where common lisp has better options(with this announcement that makes two commercial implementations, the other one being mocl: https://wukix.com/mocl).
How about crazy experimental operating systems? https://github.com/froggey/Mezzano
If you want to write native(non-swing) guis LispWorks has that covered, and the open source gtk/qt bindings, while a bit unlispy work very well. Racket has a pretty cool framework too.
There is also the fact that a lot of programmers, rationally, or irrationally, simply dislike the JVM. Pretty much everything I dislike about clojure has more to do with the JVM than the core design itself.
Both lispworks and franz maintain success lists, so you can look at some of these projects if you want to see some areas where lisp has done fine:
http://www.lispworks.com/success-stories/index.html http://franz.com/success/
Not that clojure is a bad language(I actually like it quite a bit), but compared to the professional common lisp world, it's a baby. CL has an extremely high-quality and stable specification, dozens of very good implementations for pretty much every platform(whit several ones that are decades old, and several ones that are brand new), a community that simply refuses to die, and use cases where clojure would be completely inadequate. Not to mention the assertion that non-clojure lisps are not going anywhere is completely false, both common lisp and racket(hell, even elisp) are growing in their niches and developing their ecosystems. Books and libraries are being written, products are being developed, conferences and meetups are organized, businesses are started and research is being done.
So that's several variants of lisp, as well as fortran, c, pascal, prolog and ada. Thats pretty much most of the languages in use in the 80s.
Another great example might be Postmodern and CLSQL, both of which include SQL DSLs, much better than concatinating strings or muddling around with ORMs. CL's loop macro basically ads an algol like language to lisp(if you dislike loop, there exist lispier alternatives like iterate).
Macros take care of the case between writing a function and writing an interpreter, and with judicious use, they can help build much cleaner abstractions that give a qualitative improvement to a code base.
In the scheme world, the way they deal with this is by wasting a decade on making decisions about the language that should have been done in the 80s. The result is that scheme essentially split into scheme and racket. Now we have an awesome language and a nice little ecosystem thats good for teaching and research, and possibly even real work(tm). Classic scheme unfortunately is fragmented into implementations who all do things slightly differently and occupy their own niches.
In the clojure world, they have a) a BDFL who sets the course of the language. b) A very strong core community of very smart people who managed to build a nice culture based on common ideas about software and design.
In the common lisp world, because we have a very high-quality standard, implementations are almost completely compatible. Compatibility libraries make it easy to write very portable code, avoiding the scheme problem. At the same time implementations are free to experiment. The other problem of everybody developing their own little universe tends to be rare. Because common lisp is so old, we have a long history and traditions that guide future design, but don't constrict it. There is a subtle balance here. We have a lot of old examples to learn from, but we are not locked in by too many bad old decisions(not always the case, but good enough in practice).
A few examples where this does not work include utility libraries and things like json libraries, libraries for outputing html etc. Since we don't have a BDFL we are left to figure things out amongst our selves and sometimes, like with utility libraries(there are dozens such, which is ridiculus) it doesn't work. In other cases, it works very well, for example quicklisp, ASDF, bordeaux-threads, closer-mop, hunchentoot etc. are either de-facto standards, or sufficiently popular to be a very good default. As with clojure, there are a lot of common ideas about what is good design in the community, we have a lot of examples to learn from, as I mentioned.
In the end, at least in the case of common lisp and clojure, I see it as an advantage to have this "level of possible diversity", it's what has kept lisp alive for 50+ years! The fact that lisp can adopt to each new era of software development philosophy is a great reason to study it. It will be with us for many more decades because of this.
Happy Lisping!
In summary, humans did horrible things to each other, and we survived and endured, so now with the danger out of the way we can play these games, I don't wish to continue though. I've probably stepped on a few land mines with this comment already. The whole thread is a mine field. I wish everybody pleasant evenings with history books/podcasts.
He also talks about how sometime in the future, when the pain isn't as fresh as it is now, some historian will write a book about all the benefits of Hitlers regime, like they do for Caesar or Alexander(All butchers of similar caliber). But thats pretty much impossible currently because you need the historical distance from such hard topics.
[1] http://www.dancarlin.com/disp.php/hharchive It's caller "Wrath of the Khans" and is essentially an audio book, find a couple of free evenings and listen to it if you can handle hours and hours of horror. There are also a bunch of old episodes(only recent episodes are free) on WW2 that are definitely worth the money. The most recent series is on WW1, it's still unfinished, and in fact after many hours it's barely one month into the war, you need an entire mini-audio book to set up the context for an audio book on WW1, thats insane. Fans of history will become addicted to this podcast. BE WARNED!
}
});
};
}());My brain pattern matched it as two numbers that have some relationship with each other, but It didn't even occur to me that it was a date until I visited the page. If it was written 16/11 I might have gotten it(the bigger number on the left makes it unlikely that it's a ratio of some sort which is how I read it intuitively). But what if it was 5/11 or 11/5, still no idea what it means without context. If it said "on 11/16" I would get that it's a date, but it would still take me slightly more energy to figure out which is the month as I don't associate the right number with the day, but the opposite.
Keep in mind, if I look at it for more than 2 seconds I will figure it out, but if I need to spend more than a fraction of a second parsing a date, you have a UI problem.
* http://grammarly.com a NLP startup from the Ukraine, they provide a grammar checking tool.
* http://dwavesys.com a Canadian quantum computing company.
* http://agri-esprit.com is a French agriculture startup offering software for farms
* http://onshored.com equipment scheduling and resource management software. From Chicago
* http://zenrobotics.com a Finish company making, you guessed it: robots.
* http://www.novasparks.com/ FPGA
* http://siscog.pt/ Portuguese company, offers solutions for transportation companies
* And just today on reddit I read about http://bikefriday.com whose powered by CL(read more: http://www.reddit.com/r/lisp/comments/1q1a1w/check_out_my_cl... )
As you can see, not a lot of traditional "cat pictures as a service" companies, but javascript is good enough for those, they don't really need lisp, unlike a quantum CPU manufacturer :)
- Write meaningless programs
- Play games
- Drink beer
Same as most other days actually.
Welcome to software.
While your other sentiment seems logical, if you actually look at it as a lisp practitioner, you'll find the answers to the questions you have relatively easy. You don't have to "update" the language, for many things you can just use it like any other.
The problem isn't that lisp isn't updated, but that there aren't enough of us to build the lisp django, or at least there aren't enough of us who want the lisp django for it to happen, so thats why web development in lisp is limited to using raw hunchentoot or microframeworks like Restas and Caveman/Clack(which are both pretty awesome btw). Other than a few minor tweaks, lisp really doesn't need updating. More/better libraries would be sufficient!
Can you give a couple of specific examples where you think lisp is behind the times and you are "forced" to implement whatever. I can think of maybe a handful of such instances(there isn't a really great STM, but we do have other awesome concurrency options as just one example), but the list of lisp features I miss in python(my day job) is 1-2 dozens at least(and If I had macros and CLOS I could probably half that list in a week or two :)
In other words if you are crazy enough to use lisp for useful projects, the language will help you, maybe you haven't tried? Maybe you have and just had bad luck. Some domains(GUI programming for example) aren't as well supported for example. Others are pretty ok.
Lets take a look at a few patterns I've noticed:
* Newbie posts some snippet and asks for review, the snippet is C++ code written in CL, lisper tells him it sucks, newbie explains that he has a lot of C++ experience and this is how his brain works. Lispers(now plural) explain to him that lisp must be learned with a beginners mind and he must forget C++ temporarily in order to learn it properly. Newbie gets insulted for some reason and begins arguing.
* newbie asks question about "generic lisp", lispers explain that the question makes no sense, and give his an answer about common lisp. Newbie asks question again emphasizing that he isn't interested in Common Lisp but in lisp in general, lispers tell him to read the topic, #lisp is about Common Lisp. Newbie argues that #lisp should be about generic lisp, and #commonlisp or whatever should be about CL, argument goes nowhere of course.
* newbie asks question and posts snippet. The code is obviously written by somebody with exactly 1 hour of lisp experience(parens are mismatched and aligned wrong, indentation is horrible, not to mention the obvious hacks). lispers explain that lisp is best learned patiently and not through the "learn x in y minutes" way, and that he should read Practical Common Lisp. Newbie gets insulted he was told to RTFM instead of getting an actual answer to his "wrong" question(at least in the eyes of us lispers).
* newbie asks about scheme/emacs and refuses to accept that #lisp isn't about those languages, see pattern #2.
* newbie asks scheme vs CL vs clojure vs haskell vs python vs ... question. Gets surprised when lispers unapologetically proclaim CL the best language ever and everything else is shit. Lispers do not hide their bias. Newbie then begins to argue about his favorite language and why it is better than lisp. Sometimes it's clojure, sometimes its scheme, or it could be whatever.
* (my favorite, and probably most frequent) Newbie asks what is lisp good for, gets pissed off when we tell him we program computers with it :)
Many other such questions include:
Q: "why isn't lisp popular" A: You haven't converted enough people to it :) Q: "Why does lisp have so few libraries" A: You haven't written enough libraries yet :) Q: "Why isn't there a library for X" A: Nobody needed it, if you do, write it and push it to github :) Q: "Why doesn't library X do Y" A: patches welcome.
Notice a pattern :)
All of these cases or variations of them have happened many times since I started to frequent #lisp, often times the word "fags" or "cunts" get used, and not by lispers.
In many ways Common Lisp is still a much better language than Clojure or Racket. It isn't old, compared to pretty much anything from the 80's it has aged unbelievably well, and while it has some "stale" parts you can call ugly, I find many parts of clojure or racket much uglier. All in all, it is one of the best high level languages around.
Or if you are now to programming in general:
Not to mention the traditional argument for lisp as a teaching language: the extremely simple syntax. For somebody who hasn't seen code before, lisp would look just as weird as any other language, so the unfamiliarity argument doesn't hold much water. Prefix notation isn't at all difficult to learn, (+ 1 2) would be just as weird as dividing using / or multiplying with *, and using % for modulo division. You just tell the students that this is how you write math with a keyboard(a white lie at worst:).
I'm currently working on a "try ruby" like tutorial to interactively teach FP using racket to college students, as my last year project.
Nobody is writing satellite code in CLOS, though.
Ahem: http://flownet.com/gat/jpl-lisp.htmlAlso
Even C++ would be a bit more safer depending on what flavor of CLOS you are using.
Assuming you meant CL rather than CLOS, I disagree with intensity. Considering CL is actually memory safe, and has the condition system, this this is the weird statement.CL was used for building a lot of big and expensive software, and still is in certain niches. I say actual reality trumps HN PL theorizing. True, there are challenges, but somehow actual humans have managed to get a lot of really good work done with this language.
Anyway, lispworks seems to be doing fine selling their lisp, so maybe it isn't hopeless for wukix :)