it uses nodeJS's webkit binding. You can open an inspector on any element of the UI
1,153 karma · joined April 1, 2012
it uses nodeJS's webkit binding. You can open an inspector on any element of the UI
The only thing I'm not fond of Racket is that compared to CL w/ Slime it feels way less interactive, a step up from Python, but still not CL (nor Smalltalk)
But lets focus on the positive, the OP is highlighting that the trite criticism of non-lispers about parens is bogus.
That is mostly not like not Emacs? Or did Zwei and other emacsen had the same key bindings as emacs and gnu's readline?
Their pattern matching is easier to extend than optima though.
Although I personally use loop and eschew other iteration constructs I see the point you are getting at, it communicates better the intent.
Besides Nile, the parser OMeta is pretty cool to imho.
SLIMe doesns't have a GUI but is pretty good tooling. has Autocomplete according to symbols available to your image out of the box, xref (who calls function/who setsvariable/etc), a menu for managing threads, an object inspector and much more.
[0]: http://lisp-univ-etc.blogspot.com/2013/01/real-list-comprehe...
Brit Butler has written a 6502 emulator[0] and is now writting a NES emulator in lisp[1]
Henry baker wrote a compiler for a simple lisp named 'comfy' for the 6502 chip which intended to replace it's assembly in emacs lisp[2] which has been ported to common lisp[3]
[0]: https://github.com/redline6561/famiclom
[1]: https://github.com/redline6561/cl-6502
[2]: http://home.pipeline.com/~hbaker1/sigplannotices/sigcol03.pd...
Because if it did, it would be an interpreter.
> or produce anything that is directly executable itself.
My PoV is that the CPU as a interpreter. compilers just translate. It appears to me that you are under the impression that there is something special about machine code, that compilers should generate machine code in order to be one. If that were the case I would disagree. I concur with the OP that transpiler should just be dropped, just use compiler.
Although I agree that it is generally the case, you can read here[0] for an example where CL would gain an advantage over C compilers. Albeit in an implementation specific way.
[0]: http://www.pvk.ca/Blog/2014/08/16/how-to-define-new-intrinsi...
If you ask me the strengths of Clojure that it is built upon abstraction/interfaces (ie. conj instead of cons) and how it manages hygiene while retaining quasiquotes templates leveraging clj's namespaces. But then again you should probably ask a clojurian instead.
Leo Meyerovich did a study on the social factors that affect language adoption[0]. Vivek Haldar has a highlights the salient points[1]. More info at his site: [2]
[0]: http://lmeyerov.github.io/projects/socioplt/papers/oopsla201...
[1]: http://blog.vivekhaldar.com/post/56972066006/empirical-analy...
“Why, suffering is the sole origin of consciousness. Though I did lay it down at the beginning that consciousness is the greatest misfortune for man, yet I know man prizes it and would not give it up for any satisfaction.”[0]
http://dostoyevsky.thefreelibrary.com/Notes-from-the-Undergr...
The article's first premise of what are lisp's virtues is dead wrong. First Lisp is NOT a functional language. A functional language is one that maintains referential transparency. i.e. where I can replace the reference/variable with its value its semantics are unchanged. Common Lisp is a multi-paradigm language and pervasively uses the the concept of places to setf state. And in a more general lisp sense, macros are opaque to the run-time and directly opposes referential transparency.
His second statement, Ruby gives you 80% of what you need of macros, implies that we know what macros are for. Macros are not a solved problem, you can see Racket is actively researching macros. For example, how does one do meaningful error reporting in macros? And given that macros, generally, are programming at compile time the statement is as analogous to saying we know what we are programming for, a statement I couldn't disagree more with.
The quid of Lisp I would argue is not specifically macros, but its 'meta-circular semantics', that is to say, the capacity of lisp to speak of itself in a meaningful way[0][1]. For example, in C++ we can speak of C++ but not in C++ but in its template language, that is to say a meta language. Lisp is its own meta language. We could also speak of Python in Python, for example express Python's for loop in python[2], except there is now way to replace python's definition of for with my own.
BTW, that doesn't mean Ruby isn't a good language. Lisp is not an idyllic standard from which to measure how good all other languages are. For example, Smalltalk is far from being a Lisp, that doesn't mean it is not good.
[0]: http://home.pipeline.com/~hbaker1/MetaCircular.html
[2]: https://gist.github.com/PuercoPop/9d192f94f88074d06625
[1]: "Informal "design patterns" are only for inexpressive languages. In Lisp, you can always express the "design pattern" formally, through a function or a macro. (...) No half-assed informal descriptions of repetitive patterns needed; if you can actually identify and express a redundancy using English language, you can also code a formal function or macro to get rid of it" — Fare in http://fare.tunes.org/files/fun/fibonacci.lisp
[1]: http://dept-info.labri.u-bordeaux.fr/~strandh/Teaching/Langa...