HNHacker News
TopNewBestAskShowJobs

pavelludiq

2,130 karma · joined June 6, 2008

Nerd from Bulgaria. Im lazy, inpatient and excessively proud of my self.
submissionscomments
pavelludiq··on Why I want Swift to be your first language
Both Common Lisp and Racket have keyword arguments, and even Clojure kind of has them(it cheats by using map destructuring). Common Lisps in particular are very powerful and flexible, see http://www.gigamonkeys.com/book/functions.html
pavelludiq··on Ceramic – Turn Lisp web applications into desktop apps
https://common-lisp.net/project/commonqt/ works well, https://github.com/Shinmera/qtools is an attempt to make it work better.

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 :)

pavelludiq··on Ceramic – Turn Lisp web applications into desktop apps
I am glad to see Lisp, CL, in the headlines other than clojure.

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 :)

pavelludiq··on The Opa Language
In Bulgarian it could be translated as "oops! language". Really, really unfortunate.
pavelludiq··on Debugging Lisp Part 1: Recompilation
On more than one occation when writing web code I found myself in the debugger in the middle of a request handler. The browser just sits there waiting for a response. I found the bug and restarted the handler before the browser time-outed. The browser recieved the response as if a bug never existed. Of course this only works if you can find and fix a bug in under 120 seconds :)
pavelludiq··on Lispworks 7.0 with Mobile (iOS, Android) Runtime
Specific domains where clojure might not do so well are probably the same domains where the JVM is impractical, for example embedded or low-level programming, anything where you have to interact heavily with the world outside of the JVM and have a small footprint.

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/

pavelludiq··on Lispworks 7.0 with Mobile (iOS, Android) Runtime
Yes, abandon something that's been making money for 30 years and throw away decades of domain expertise because it's not fashionable. Great idea.

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.

pavelludiq··on LibOS – A library operating system for Linux
https://en.wikipedia.org/wiki/Genera_%28operating_system%29#...

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.

pavelludiq··on Fear of Macros
My favorite example would have to be CLOS the Common Lisp object system. Although it's a bit hairy in certain places, it essentially transforms a procedural/functional language into on of the most powerful object oriented languages around. Macros play a small, but crucial part of it, subverting the rules of lisp in order to add another dimension to the language.

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.

pavelludiq··on A Haskell Programmer Tries to Learn Racket
Show me a language with >1 implementation where at least two are completely compatible. Common Lisp has one of the best track records in this aspect. C, C++ and JavaScript are all far worse.
pavelludiq··on A Haskell Programmer Tries to Learn Racket
As a lisper, I can say that this insight is very true, but it is still just a simplification. Most lisps deal with it in different ways.

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.

pavelludiq··on Racket 6.0: New package system, new doc CSS, JIT support for ARM
Geiser is great, but SLIME is much better mostly because Common Lisp was designed with interactive programming in mind(the condition system, the object system, dynamic variables ect. are all features that help with interactive programming). You get an almost smalltaskesque feeling with slime.
pavelludiq··on Racket 6.0: New package system, new doc CSS, JIT support for ARM
All the major lisp dialects are rather different and encourage different styles. My own opinion is that no one is a better first lisp, as long as you check out the others eventually. Racket is an excellent start. I always advise people interested in lisp to check out racket, clojure and Common Lisp in whatever order they wish. I started with scheme in 2008, moved to clojure in 2009 and I've been a happy Common lisper since 2010/11. Depending on your own style as a programmer you might choose a different main dialect you like best, but only after you try them all :)

Happy Lisping!

pavelludiq··on Time travellers: please don’t kill Adolf Hitler
The mongol conquest was almost certainly a net negative for humanity(Baghdad recovered only in the 20th century as just one example). But the standard argument is that suddenly you had chinese culture spread to the west somewhat. Not to mention after all the killing was over, trade was more free and safe for a while. If you had the Khans permission to travel in the empire, you didn't have to worry too much about a random tribe looting your caravan. Mongols were also very tolerant of other religions as long as you submitted to their rule. Marco Polo probably wouldn't have made it to china without that region being "passified". The same argument could be used in the case of Alexander or Caesar or Napoleon. You could also say that the conquista was a good thing for the American continents, but that would depend on who you ask. This is a fairly complex topic well beyond my knowledge as a fan of history, not to mention I touched on a subject thats very sensitive to a huge portion of the population of the world. Most of us have ancestors who were conquered and few of us view it as a good thing.

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.

pavelludiq··on Time travellers: please don’t kill Adolf Hitler
History is weird that way. I recommend listening to Dan Carlin's Hardcore History series on the Mongols[1] where he talks about how historians often justify unspeakable horrors because in hindsight there are a lot of benefits to modern civilization. He balances it out by saying that the benefits don't look so good if you have to ask the people who actually have to pay the bill. Millions of Chinese, Muslims, Russians and Hungarians who actually had to pay for the benefits of Genghis Khans conquest would probably not see it as a good trade off to endure literally the end of the world.

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!

pavelludiq··on Emacs, naked
I'll certainly give lighttable.el a try when somebody decides to write it :)
pavelludiq··on What is your best programmer joke?
actually, it was javascript and the file contained:

              }
          });
      };
  }());
pavelludiq··on Commit 15 minutes (11/16) to explain to a stranger why you love your job.
(I'm not from the US)

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.

pavelludiq··on Ask HN: Are there any current startups using Lisp?
With all due respect, get lost. Flaged!
pavelludiq··on Ask HN: Are there any current startups using Lisp?
There are many companies that use various lisp dialects. Not many would be described as startups, but a bunch of them exist. A quick scan of http://lispjobs.wordpress.com will give you a few names:

* 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 :)

pavelludiq··on Little Brother
Kevin Mitnicks autobiography "Ghost in the Wires" is very good. Although it's non-fiction, it read like a cyberpunk spy novel.
pavelludiq··on Happy Programmers' Day
Traditional programmers day celebration in Bulgaria:

- Write meaningless programs

- Play games

- Drink beer

Same as most other days actually.

pavelludiq··on A Personal Lisp Crisis (2012)
" There's always a dozen incompatible solutions, and it's never clear which one should be used."

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.

pavelludiq··on A Personal Lisp Crisis (2012)
Completely agree. One thing that I figured out rather quickly is that lispers really want to teach and explain things, but being lazy programmers, they don't bother holding your hand, so if you are willing to do your homework, you'll have an amazing time with lisp.

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.

pavelludiq··on On Lisp
Bullshit!

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.

pavelludiq··on On Lisp
Actually a much better place to start is Practical Common Lisp:

http://gigamonkeys.com/book/

Or if you are now to programming in general:

http://www.cs.cmu.edu/~dst/LispBook/

pavelludiq··on On Lisp
I'd advise exactly the opposite. While clojure and racket are excellent languages, they are very different from one another and CL. Telling someone to learn python or ruby if they ask about learning lua isn't a good advice, is it?
pavelludiq··on High school programming taught in Haskell in Argentina
If you want an interactive system, clojure or common lisp will be much better choices. Part of the reason I haven't gotten into haskell is because as you said, it "isn't quite there yet". Common Lisp has the added quality that an error trows you into the debugger, and that it makes errors much less punishing. If there is one lesson I've learned from gaming is that hard games don't repel the players if errors are easy to recover from and you aren't psychologically punished for them. Haskell isn't exactly a shining example of that, despite it's other great qualities. You want to make the teaching material challenging, not punishing(a great example of this is the game super meat boy).

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.

pavelludiq··on The Art of Lisp and Writing (2003)

  Nobody is writing satellite code in CLOS, though. 
Ahem: http://flownet.com/gat/jpl-lisp.html

Also

  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.

pavelludiq··on Mocl – a Common Lisp implementation for mobile platforms
the eclim talk mentions that many CL libraries work with it so maybe https://github.com/fons/cl-twitter or https://github.com/skypher/cl-oauth will work?

Anyway, lispworks seems to be doing fine selling their lisp, so maybe it isn't hopeless for wukix :)

← PreviousPage 3 of 22Next →