Hacker News Reader

Comment by dschiptsov | Hacker News Reader

mr. Norvig is a great man, no doubts. Have you read AIMA, by the way? I did.)

This, of course, is not a "complete" Lisp. Let's say that [one of] the most fundamental feature of a Lisp is ability to define a new "special form" (without modifying the code of the interpreter) as a [reader] macro. This is the way of defining a DSL. the loop constructs, structures, even whole CLOS is nothing but a DSL.

All we need is quote, quasi-quote, unquote, unquote-splicing, the "conses-aware" read function which "expands" these and the if special form that "short-circuits".

This (everything is made out of conses + general evaluation rule + reader macros) could be called a Lisp.

Want to see a Lisp? Look at arc.arc

View on HN

This “DSL” acronym is used everywhere nowadays; mistakenly so I think. A DSL (domain specific language) is like cold-fusion, R or VHDL; it is a complete language designed with the target domain in mind.

Now tell us, please, how looping constructs in CL aren't DSLs and how it how it contradicts your definitions.

hint: the term DSL was popularized by SICP. One needs high-order procedures to implement a simple DSL, the feature which wasn't available in most language but Lisps.

Well, looping constructs are not related to a particular domain (e.g. electronic circuit design), but are general purpose construct.

>Let's say that [one of] the most fundamental feature of a Lisp is ability to define a new "special form" (without modifying the code of the interpreter) as a [reader] macro

That's not fundamendal at all. If anything, either seldom used or frowned upon.

Sorry? The ability to add looping constructs and other control structures, like with* or defstruct/defmethod etc. to CL isn't fundamental for CL as a language? What is fundamental, then?

And, please, don't tell me about the Lisp 1.5 - it was "fundamental" but has been evolved since then.

btw, if you really do look inside arc.arc you will see "a bunch of nested macros".) This approach, championed by pg (or rather rtm) and described in the classic On Lisp book is, in some sense, the culmination of the few selected ideas behind a Lisp - you evolve the language as your understanding of the project deepens (evolves) by hacking appropriate DSL as you go. It is not just a "book stuff" - Arc is very real thing and this very site has been built very quickly (and cheap) using this very approach with very few lines of clean, readable code.

Ironically, we are using these pages to discuss "religious nonsense" such OO-is-the-only-way, Java-is-the-proper-everything, Scrum-is-the-way-to-manage-big-projects, or "sectarian stuff" like Javascript.)

Well, one can get quite far without writing macros.

SICP for example writes (almost) no macros. Norvig himself has written only a few macros for his book PAIP.

Yeah, having high-order functions gives you the ability to write "a primitive" DSL, which is the one of the big ideas from SICP.

The limitation is that all the arguments to your high-order function will be evaluated before its application, so if you need a special form (with its own evaluation rule) you have to write a "short-circuiting" macro transformation. This is how to write "advanced" DSLs.

Almost a 2/3 of Arc are macros, but, yes, there are very few "special forms" among them.

As for PAIP, he loves structs and looping DSLs, while, at least for me, the beauty is hidden in explicit recursive calls for traversing a recursive data-structures (lists, trees, graphs) made out of conses. I'm Brian Harvey's man.)

>Sorry? The ability to add looping constructs and other control structures, like with or defstruct/defmethod etc. to CL isn't fundamental for CL as a language? What is fundamental, then?*

Who said anything about CL in specific? The article is about "how to write a Lisp in Python".

Second, no "reader macros" are not "fundamental", even for CL. Well, except if you mean the built-in ones, like #. But surely, adding custom reader macros is neither necessary nor fundamental for CL (nor are non-lispy DSLs). And they sure aren't for a simple Lisp (as in TFA).

From TFA:

"the beauty of the language is that we only need six special forms"

P.S Anybody who downvotes = disagress, does he also have any counter-argument?

"the beauty of the language is that we only need six special forms" - this is an oversimplification.)

There are not mere "only six special forms" involved in what makes a Lisp "a miracle". There is, in my opinion, a small, well-balanced set of ideas/principles which are complementing each other. Notably "everything is a symbol (pointer)" semantics, common for code and data cons-based underlying representation, so "the code is data" maxim makes sense, the uniform general evaluation rule for prefix-notation expressions, the "list-aware" reader function, to name the few.

All these ideas or principles aren't CL specific, on the contrary, these are common for all Lisps. CL is just a good example of incorporating mini/specialized DSLs (loops, format, etc).

I have tried to describe "how the miracle works" but failed miserably.) These are my counter-arguments.

http://karma-engineering.com/lab/blog/Good-ideas

http://karma-engineering.com/lab/wiki/ProperUnderstanding

http://karma-engineering.com/lab/wiki/Bootstrapping1

http://karma-engineering.com/lab/wiki/Bootstrapping2

The "downvote if you disagree" has gotten to a rather stupid point here lately.

In nearly every submission I read the comments of these days, I see numerous perfectly fine and valuable comments in gray text.

Since so much good content ends up in that state, it renders such styling pointless. Gray text no longer means that the content is very likely commercial spam or otherwise without much value.

I even go out of my way to read all of those comments. With so much good content being downvoted these days, they often have some of the more insightful remarks.

The "downvote if you disagree" has gotten to a rather stupid point here lately.

It's even gotten past that to the "flag if you disagree" point. I call that the "douchebag census data." Those users should be shunted to another "tier" of the site that's even subtler than hellbanning.

http://norvig.com/lispy2.html does support macros.

This one is better, indeed.)

My point wasn't about mr.Norvig's essays - they are extraordinary and elegant, my point was about what is a toy [Lisp] and what isn't.)

Reply on news.ycombinator.com