HNHacker News
TopNewBestAskShowJobs

PuercoPop

1,153 karma · joined April 1, 2012

submissionscomments
PuercoPop··on Taking it to Th’emacs
Yes, tit the default mode is through regexs, and most of the modes use it.

But I think the OP's point was you are not limited by it, besides semantic (which I haven't never bothered to setup, there is js2-mode[0] as examples of modes that don't use regexps to operate on the language. There is even js2-refactor[1] built on top of it. You can read about js2-mode origin story here[2], and you would see that lack of threads in elisp hindered its development.

[0]: https://github.com/mooz/js2-mode [1]: https://github.com/magnars/js2-refactor.el [2]: http://steve-yegge.blogspot.com/2008/03/js2-mode-new-javascr...

PuercoPop··on Taking it to Th’emacs
I use jedi.el along with virtualenv-wrapper which does jump to definition perfectly fine ime. But keep an eye for open sourcegraph's mode[0], they are going incorporate python soon AFAIU.

[0]: https://srclib.org/plugins/emacs/

PuercoPop··on Why Racket? Why Lisp?
mutable cons cell by default is a very big departure from the Scheme Standard AFAIU (not that I think it is a bad idea, just not Scheme).
PuercoPop··on Why Racket? Why Lisp?
I don't know about Swift but equating a REPL to interactivity is a horrible disservice to Lisp (and Smalltalk).

For example, Python has a REPL but it is not very well suited for interactive programming. For example Python does not handle you redefining a module after you import it without some voodoo. Nor it has forward references. For example in Lisp I can define a method that especialices on a class I haven't yet defined. Or define a function that calls function B which I will define later in the code. Nor have I seen something akin the slime Inspector and presentations, which are not quite there as the Symbolics Genera environment for interactive programming

PuercoPop··on Why Racket? Why Lisp?
Great concrete examples, a couple of things to add about them:

Handler, conditions and restarts are much more expressive than in other languages, you can signal a condition (the analogue of throw) with restarts attached to it which only if you desire to handle it in another part of the program where(/if) you decide to handle the conditions(the analogue to try). It is analogue to throwing an error with catch statements attached and when you write the try statemet the catch statements attach to the throw statement are made available to said catch. Kent Pitman explains it much more eloquently than me[1].

Also to add how well thought out CLOS dynamic redifining of classes is, when one redifines the change is garaunteed to happen between redefinition and the next time you access said class, as to give leeway to the implementation to decide the best strategy to do so (for example if redifining a class with 10K+ instances if you do it all at once the system may become unresponsive). Also if the redefinition isn't just adding or removing slots you can provide a function to handle the updating of slots for the redefinition.[2]

[1]: http://www.nhplace.com/kent/Papers/Condition-Handling-2001.h...

[2]: http://www.lispworks.com/documentation/HyperSpec/Body/f_upda...

PuercoPop··on Toga: A Python native, OS native GUI toolkit
Not really novel[1], just not used enough

[1]: https://en.wikipedia.org/wiki/Sketchpad

PuercoPop··on A Lisper's first impression of Julia
It is in poor taste to put words in someone's mouth and proceed to 'debunk' said words.
PuercoPop··on A Lisper's first impression of Julia
It only seems weird in so far that you are ignorant (aren't we all?) of the generic function approach to object orientation.

In the message passing approach you dispatch based on the type of the first argument to the method. Because it would be redundant to explicitly write down the argument it is commonly syntactically elided (though not fully in Python) and you get coupling of the methods and the object. This is not a fundamental property of OO but accidental feature found in most OO languages.

In the generic function approach, the dispatch is extended so one can dispatch on the type (among other things) of (ideally) all of its arguments. Julia follows this approach afaik and if one is familiar with the generic function approach it is not a controversial claim at all.

Erik Naggum explains it here in more depth: http://www.xach.com/naggum/articles/3243735416407529@naggum....

PuercoPop··on Learn Lisp the Hard Way
Sorry, my mistake. Don't know where I got the idea that I had seen D-wave on your gh profile.
PuercoPop··on Learn Lisp the Hard Way
Regarding the tone I concede it is a little over the top, but considering the author works for D-Wave[1] building the future of (Quantum) Computing I think it is not without merit.

It may be better to leave the intro part for the end as it may alienate programmers that have preconceived notions about lisp based on hearsay and not actual experience (i.e. it's enlightening, it's old, full of cruft, hard to read, it's functional, Clojure is the future of lisp).

It is also very much a WIP that the author didn't submit so keep that in mind.

I hope he gets to writing the chapter on Quantum computing: http://learnlispthehardway.org/book/3-14-0-quantum-computing...

[1]: http://www.dwavesys.com/

PuercoPop··on Learn Lisp the Hard Way
Wrong either way. Because it is so easy to parse by computers it is easy to use them to format it. Have you tried reading foreign (as in not written by anyone you know) lisp code? IME It is not hard(er) than any other language.

For example, IME delving into the codebase of hunchentoot was way easier than django's.

PuercoPop··on Learn Lisp the Hard Way
You could even just write "Hello, world!"!
PuercoPop··on Learn Lisp the Hard Way
> Lisp asks a lot of the user up front. Like what? Last time I checked you get a repl and type away. If you have a mac you can install CCL from the app store and don't even have to use the terminal to get to a repl.

> Python doesn't. C# doesn't. Fuck, Python is so loose that you don't even really need to know what any of the structure is to start writing something that kicks back some output.

again, not unlike lisp.

> Lisp isn't THAT hard', but that's bullshit. Lisp IS that hard

Care to back up that claim? AFAIR The SCIP barely spends a page explaining the semantics. The CONCEPTS in teaches are hard(er) but they are not lisp. In fact one of the reasons the SICP was written in Scheme is so that you _don't_ have to waste half a semester teaching the language before you can get to the fun, important, useful stuff. The little schemer doesn't spend much time teaching lisp either.

PuercoPop··on Crane: An ORM for Common Lisp
Postmodern is built upon s-sql while Crane on sxql. Also Postmodern's DAO doesn't strive to be an ORM.
PuercoPop··on Crane: An ORM for Common Lisp
I uses the 'ArielNetwork/Fukamachi' style which has a lot of @ reader macros and recommends a one package per file. Although not on all files.
PuercoPop··on Cdb: a fast, reliable, simple package for creating, reading constant databases
IYAI Common lisp's quicklisp implements and uses cdb https://github.com/quicklisp/quicklisp-client/blob/master/qu...
PuercoPop··on Opal: Ruby in Your Browser – the Basics
How is assembly going for you? What is fundamental to the web is the APIs (dom/websockets/webgl/...) not the fact that they are exposed through javascript. Dart seems especially nice considering that they go out of their way to provide (most?) html5 apis in dart and also Angular.

In fact the dom is defined in an IDL which can generate the dom API not only in javascript but a lot of other languages (Java/C++/etc)

PuercoPop··on Chromium on Linux replacing GTK+
Although you are technically wrong, it is LGPL, you are right. It is dually-licensed, but it doesn't vary according to the target platform.
PuercoPop··on In Praise of Perl 5
Perl has reader macros and a meta-object protocol upon the object system is built with. Ruby and Python don't have either AFAIK. That is an example of what the OP is saying with Perl is an extensible language.
PuercoPop··on Neovim
Have you seen http://xiki.org? It seems a good idea for the she'll to know what a directory is for example.
PuercoPop··on Common Lisp in the 21st Century
Damn right, I love how clojure hosted semantics import all the great features of their host. Like how clojurescript has only floating point numbers and coerces string to numbers when using the + operator.

In all seriousness, I mad love to Clojure, but is a different language with different sensibilities/tradeoff. Not a 'better' CL. For example, I imagine that interfacing with c code using cffi should be way easier and simpler than using JNI and then exposing that to clojure. Or having defined semantics for numerical computations.

PuercoPop··on Library Documentation Hosting for Common Lisp
Thumbs up to Fukamachi for quickdocs. It is helpful for a bird's eye view of the project. The next step would be something like sourcegraph.com where examples of the functions being used are linked to.
PuercoPop··on Julia 0.2 released
I think another big advantage of CLOS that Julia took is that you can dispatch on the type of not just the first argument but on the combination of the types of all the arguments
PuercoPop··on What's wrong with Object-Oriented Programming and Functional Programming
http://www.pvk.ca/Blog/2013/09/19/all-you-need-is-call-slash...

Think again, Paul Khoung walks you through implementing some monads using call/cc

PuercoPop··on Why Java Now Rocks More Than Ever: Part 1 – The Java Compiler
It is called Common Lisp
PuercoPop··on UTF-8 – "The most elegant hack"
Except that because, in unicode, there is no one-to-one correspondence between code points an character, so even in utf-32 providing i-th char is not O(1). As Richard O'Keefe clearly explains: "Now as it happens I don't think random access is important. Here's why. Consider Ṏ. There are three ways to encode that: O + ̃ + ̈ | Õ + ̈ | Ṏ. This one "user character" may be one, two, or three code points ..." [1]

[1]: http://erlang.org/pipermail/erlang-questions/2011-October/06...

PuercoPop··on A Personal Lisp Crisis (2012)
>> Another question is whether there should exist a "sys lisp" that can form the lisp core of higher level lisps but that itself is not a garbage collected lisp...

You may be interested in Henry Baker has a paper where he shows a VM where the semantics prevent garbage from being created http://home.pipeline.com/~hbaker1/LinearLisp.html

PuercoPop··on Unix Commands I Wish I’d Discovered Years Earlier
Protip, you can make emacs use mdfind with (setq locate-command "mdfind")[1]

[1]: http://emacsredux.com/blog/2013/07/05/locate/ (setq locate-command "mdfind")

PuercoPop··on My first project in Rails – Pastebin for Mathematicians
I can't find a link to the source code
PuercoPop··on Nokia acquired by Microsoft
You are misunderstanding his use of the word commodity and hence his point. He is using commodity in the sense that to satisfy the demand of the item the manufacturer is irrelevant to the buyer. Clearly not all phones as commodities. An iPhone is not the same as a Chinese knockoff.
← PreviousPage 9 of 12Next →