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 Dialects of Lisp
Common Lisp is 29 years old(if we count from the publication of CLTL1) or 19 years old(if we count from the publication of the ANSI standard), clojure is 5-6 years old. Scheme is even older. I love clojure, but it has some mighty big shoes to fill, CL was build for longevity from the beginning. Also, both scheme and CL run on the JVM. CL also survived the death of many operating systems, architectures and platforms in those 29 years, clojure is yet to survive one.
pavelludiq··on Is Lisp still useful in today's world? (2011)
ABCL, a common lisp running on the JVM is getting better and better by the release. It's java interop isn't quite as polished as clojures, but it is usable, and you get Common Lisp, which I like slightly better than clojure.
pavelludiq··on Is Lisp still useful in today's world? (2011)
Compatibility libraries exist for nearly every implementation detail like the one you describe. Threads and networking being incompatible was a valid concert 15 years ago.
pavelludiq··on Is Lisp still useful in today's world? (2011)

  eval("dangerous python code here")
As I pointed out, it is a problem in any language that has eval. The way you deal with it, is you never eval anything untrusted, which is actually extremely easy to do. I don't believe I've ever used eval ever.

In CL specifically, because the reader can evaluate code as well, every time you use the read function, you should know these two things: 1) never use it for user input. 2) bind read-eval to nil. You'll be fine, or more accurately, no worse than anybody else :)

On the other hand macros, and having a json style serialization format that is much more powerful and actually extensible is a big plus :)

pavelludiq··on Is Lisp still useful in today's world? (2011)
yes, usually anything having to do with recursive structures, like threes, is a good fit for recursive algorithms. In fact, the function I wrote had to generate a directory structure out of a template: https://gist.github.com/pvlpenev/4760658 (and i still used loop :)

But keep in mind that some things, although recursively defined, are better computed in other ways, the most obvious example is a Fibonacci sequence, which if I really needed, I would precompute and stick in an array for constant time access or something like that(maybe memoize a recursive function).

pavelludiq··on Is Lisp still useful in today's world? (2011)
Define dangerous? Are you concerned with security? In which case, don't eval untrusted code, and you're fine.

Maintainability? If done right "code is data" could improve the maintainability, or decrease it drastically, just like any other feature. If you have 80 lines of comments for every 10 lines of code, you've decreased your maintainability, comments are dangerous by that logic.

pavelludiq··on Is Lisp still useful in today's world? (2011)
CLOS and MOP, read-write consistency, restartable exceptions, reader macros, optional typing, many high-quality implementations(including several commercial ones that come with excellent support), high-quality standard document, probably still the fastest dynamic language around, superb introspection support, one of the best interactive work-flows, surpassed only by smalltalk, DECADES of being tried and used in every conceivable industry and application, from super computers, space probes and AI, to web apps, games and prototyping(you'd be surprised how much software was prototyped first in lisp).

AAAAAND macros too, I guess. They are nice.

</smuglispweeniecomment>

pavelludiq··on Is Lisp still useful in today's world? (2011)
I've been using Common Lisp for two years now, I've written exactly ONE recursive function that wasn't an exercise or an example. Functional interfaces to functions with local state in loops? What exactly is wrong with that?

For example it is my opinion that this function is in no ways inferior to a recursive equivalent:

  (defun range (end &key (start 0) (step 1))
    (loop for i from start to end by step
      collect i))
pavelludiq··on Kevin Mitnick
"Ghost in the wires", his auto-biography, was also a great read. It was very entertaining, and certainly worth a re-read when I have the time. It reads like a cyberpunk thriller set in the 80's and 90's, except it's not fiction.
pavelludiq··on How Lisp is Going to Save the World

  GUI libraries and frameworks are so easy with C based languages, because they contain powerful tools that I don't have to write myself.
But you DO have to write them your self. Thats just how open source works. Open source isn't about getting free stuff. People had to write those tools, and they did, because they cared. Lisp isn't so great because McCarty made it great, it's great because for 50 years people worked fucking hard to make it great. Standardizing common lisp took 10 years and a shit ton of money. Every library took months or years out of someones life. You get all that for FREE. If you really care about lisp, you will actually work to make it better. You will be one of those who spend their time and money on it.

Being one of the countless people complaining on forums impresses no one, only makes your ego feel better, doesn't actually help at all. In fact, it's hurtful to lisp, because curious people might read your comments and conclude that lisp isn't worth it for them, and for some of them, it might be, it certainly was for me. So that is why I'm angry. I'm actually trying to help you and lisp, not trying to insult people. If you care about lisp, you'll make it better, if you don't, just do something else, and be happy with it, if lisp can't make you happy. Complaining is a non solution, and I dislike non solutions.

pavelludiq··on How Lisp is Going to Save the World
I've never used cl-opengl, but the usual nameing convention for lisp names is as follows:

  name-with-multiple-words

  *global-variable*
so GLOBAL_VARIABLE and NameWithMultipleWords or name_with_multiple_words are easy to figure out. Any body who has used lisp for more than a few days knows how to name things, and since the combinations of naming schemes in C is finite, figuring this out is close to common sense. so glLoadIdentity() in lisp is (gl:load-identity).

Happy Hacking!

pavelludiq··on How Lisp is Going to Save the World
The hyperspec is standard document, not an introduction. It's an invaluable reference you use after you get familiar with the language. I also have emacs set up so that I can look up symbols from within my source, and have the relevant page open up in a w3m window in emacs. I use it constantly and miss the same level of quality and clarity in other language documentation, but you need to get used to it's style and format. If you want to get started with lisp, you go to http://www.gigamonkeys.com/book/ and http://www.cliki.net/

Learning lisp wasn't any more difficult for me than learning any other language. "Practical common lisp" is well written. "Object oriented programming in common lisp" is a well written book as well, "Land of lisp" was fun, and not too bad either.

The core language is extremely well documented and understood. As for the libraries, some of them are well documented, some of them aren't. After the docs for RESTAS started going slightly out of date, I just opened the source and read it all in an afternoon(~600loc), and mostly understood it. I prefer not to have to do that, but claiming it makes it extremely difficult to learn, I don't know, to me it's just an inconvenience, and I have a much better understanding of the framework now, which I couldn't get from just reading docs. And some libraries are so small, I can just figure them all by inspecting the package in slime, and reading the docstrings. Usually there is at least example code. The situation isn't perfect, but it is more than possible to use lisp libraries with great success. Most authors are also pretty approachable on irc or the mailing lists. In other words, I'm a young amateur programmer, who picked common lisp less than two years ago, I'm barely competent as a programmer, and I could figure this all out, why can't expert programmers with years of hacking behind them do the same, I can't understand.

PS as for the ugliness of the hyperspec, I'm happy if it scares away people who get impressed by "modern" design, more than substance and content. I usually read it in text only browsers, and curse docs I can't read well from within emacs. Alt-tabbing to a browser and having to use the mouse while hacking ruins my day :)

pavelludiq··on How Lisp is Going to Save the World
Are you trolling? First off, learning C well enough to understand opengl documentation will take you much less time that understanding opengl it self(since you'll only need to read and not write C). You have a problem, people gave you a solution, having separate cl docs for opengl that have THE SAME contents, but using lisp function names instead of C ones(as it was explained, it is simple function to transform one into the other in your head). What the hell do you want?

PS I forgot why I stopped commenting on HN threads about lisp. If you read the old usenet, this kind of discussion has been plaguing lisp since day one. People complain, and when given the solution, they just start bitching about something else, avoiding the solution. There are no docs, now the docs are in C, what else? As I've become part of the lisp community, I learned the proper way to fix this, If I encounter deficiency in the lisp ecosystem, I deal with it if I can, and If I can't I politely ask the author/maintainer if they have time to work on the issue. If they don't have the time, I simply accept reality, and move on with my problems. Bitching on HN solves nothing. Honestly, why lisp? Why do people have this supreme need to express their dissatisfaction with a language, with libraries developed by humans in their spare time away from their lives, for free. Be fucking happy, and help out if you care about lisp, otherwise, just shut up!

pavelludiq··on An opinionated guide to Scheme implementations
This is part of the reason I dislike scheme. Too many incompatible implementations. I'm a die hard common lisp fan, and I love the fact that cl has many implementations and that any software I write will run on most or all of them unchanged. With scheme, any interesting software pretty much has to be written for a particular implementation, because scheme is simply too small.

I sincerely hope that the new standard would help here. Splitting the language into a big and small system seems like a good compromise between the traditional scheme goal of minimalism and pragmatism. I'd like to hear schemers opinions on this, does the new "big scheme" really address the issue of fragmentation?

pavelludiq··on The Newbie Guide to Common Lisp
I find common lisp to be plenty practical, its libraries mostly satisfactory(restas/cl-redis/cl-closure-template make a good combo for playing with web development), and its community's frankness and no bullshit attitude are rather refreshing after spending some time in the land of the cool kids. Also these lists of success stories contain some impressive shit:

http://www.franz.com/success/ http://www.lispworks.com/success-stories/ http://wiki.alu.org/Industry%20Application

PS Land of lisp is an awesome book.

pavelludiq··on The perils of Lisp in production
The biggest programs I've worked on are way smaller than 1MLOC, but I've dug around a few large code-bases written in dynamic languages(emacs most notably, 1M lines of Lisp, 1/4M lines of C), and my unproven theory of large systems is that it might be a good idea to make mistakes have smaller impact, rather than try to avoid them(they are inevitable), by focusing on better abstractions, and thus keeping problems more local, focusing on the protocols rather than on the implementation. Static typing might help here, but designing a protocol/interface/api/dsl is hard and I need to experiment a lot with it, so I'm willing to sacrifice some safety for better overall design and flexibility(which will hopefully make debugging easier). IOW I agree you need DSLs, polymorphism and all that good jazz. Where my disagreement comes in is that It's a trade off, and not necessarily an absolute need to have a lot of static typing. In my personal work I'm willing to make the trade off and work with clay rather than marble. Other people work and think differently and I accept that; absolute truths are rare in computer science, and don't exist in software engineering, its all trade-offs here :)

ps My hobby vaporware CL project will probably be called mudball, I'm trying to learn how to design systems with hackability and extreme flexibility in mind :)

pavelludiq··on Lisp in the Cloud - The Next Lisp Machine Will Be Everywhere
SBCL is still the best open source CL(on linux at least), but ABCL is definitely getting better and better, its worth a look at the very least. I've been meaning to try it out for a while now, it looks very promising. I would also like to know if anybody has done anything interesting with it.
pavelludiq··on Vagina Invalidation Argument
The original quote was about assuming its futile from the start. "Don't argue with men"! not "Don't argue with men when you're convinced its futile". This sort of passivity pisses me off. Assholes must be called out. I'm an asshole sometimes and if it wasn't for the people who told me my behavior was unacceptable I would still be an asshole. Thank you all who've been brave enough to teach me a lesson. I believe most people are like me and will learn if given the chance. Difficult and futile are very different things in my world.
pavelludiq··on Vagina Invalidation Argument
I disagree. Although there might be situations where I would personally chose passive aggression over being honest about peoples mistakes, I would strongly prefer it if people told me I screwed up instead of gently nudging me in the "right way of thinking". I can make my own mind about what is the right way, thank you very much, If I had missed something important and made a mistake i need to know about it. I trust others to do so as well.
pavelludiq··on Brogrammers Bring Frat-House Ethos to Engineers’ Geeky Coding World: Tech
To paraphrase Daria: its not bad enough everybody in the tech world thinks they're smarter than me, now they think they're cooler than me too? :)
pavelludiq··on ITA Emerges from Google's Shadow, Unveils New Airline Platform
I can't say i disagree with BigCo on this one. If one wishes to use better languages the options are to switch jobs, start your own company or stay, but push to augment the existing codebase with other JVM languages. Clojure and Scala people have had some success starting skunkworks projects. But a complete switch? In most cases thats insanity. Companies have actually died trying to rewrite their apps from scratch. And even a slow gradual rewrite might take too long and be too expensive, not to mention not bringing any immediate benefits, because you're not adding new functionality and fixing existing bugs.
pavelludiq··on ITA Emerges from Google's Shadow, Unveils New Airline Platform
I imagine rewriting a large code base in any language to be very expensive, I doubt somebody can justify such an expense just because a bunch of new hires don't want to use a language. Companies don't rewrite java apps in lisp because a new of college grads don't want to use java.
pavelludiq··on Clojure Implemented in Pure Python
Wouldn't SBCLs type inference(+ type hints) help with this? I'm no compiler expert, but i think clojure(with the possible exception of multimethods, which are slow even on the JVM) would map well to CL(maybe even better than the JVM).
pavelludiq··on Node.js to pass Ruby on Rails in search popularity
Does anybody other that clueless managers actually make tech decisions based on search popularity? I can see some limited value in choosing one project over another because of popularity in general, but as long as there are more than 10 projects using it, popularity is irrelevant compared to other criteria, like the actual quality of a tool.

Seriously, this popularity contest between node and rails is getting annoying, open source is not high-school, quit obsessing over useless numbers and write awesome code.

It's 2012, you can get away with using whatever you like, even Haskell or Lisp, choose whatever works best for you. On the internet nobody(relevant) cares if you're a dog(to paraphrase the popular quote).

pavelludiq··on Pretty Lisp
I'm a lisp history nut, but I wasn't around at that time. Paredid doesn't really turn emacs into a structure editor, its more like a "standard editor with some of the better ideas of structure editors miked in" kind of mode. Structure editors introduce a lot of complexity in general. Maybe Interlisp was able to work well in practice despite the added complexity, I don't know, I really would like to know more about such systems.

As for your last sentence, Erik Naggum who had a bad opinion on structure editors in general, seems to have liked the idea of a structure inspector, as in using such tools to inspect code, ratter than create it: http://www.xach.com/naggum/articles/3064225496493947@naggum....

pavelludiq··on Pretty Lisp
In the lisp universe the future was in the 80's, thats when we tried the whole "structural editors" idea and concluded that they didn't work out as nicely as we hoped. I believe the sgml people tried them too, with poor results as well.
pavelludiq··on Why I don’t like Dynamic Typing
I've fallen in love with hybrid systems like Common Lisp. SBCL is dynamically typed, but type inferred and I have the option of adding type declarations to help the compiler out. It's a different way of thinking, you're working on a living system, instead of treating your program as a monolithic block that the compiler has to prove satisfies some static constrain, you work on chunks(functions, classes, etc.) that you compile and test immediately while your program is running, and if you screw up, the system is there to help you figure out what went wrong and fix it, without killing your process. Wetter or not this type of incremental development is better or not for some definition of better, I feel it fits the way I think better. Maybe somebody with a different way of thinking will actually perform worse in such an environment, thats my theory at least. I know I'm faster(and much less annoyed at my compiler) this way.
pavelludiq··on Giles Bowkett summons monsters
In many of his usenet articles Eric Naggum admits to putting traps for 'stupid people' in his posts. Anyone who's read any amount of Naggum rants knows this had interesting results. For instance, people would 'suggest' he use more polite language, and in response would get flamed.
pavelludiq··on Clojure implemented on top of Python
Why reimplement all of clojure as an interpreter? Why not just rewrite the java parts in python and compile to bytecode? Honest question.
pavelludiq··on What's new in Firefox 10 (shipping this week)
Pentadactyl -> Vimperator <=> XEmacs -> GNU Emacs. Its a political fork and PD maintainers claim its more actively maintained and developed.
← PreviousPage 5 of 22Next →