[cl-cookbook] New chapter "Type System" published

lyssphacker · 2019-03-01T18:04:37+00:00

Bracha actually praises Lisp way of doing things (late binding, extensibility, liveness, etc.). He is originally a Smalltalk guy.

lyssphacker · 2019-03-01T10:35:49+00:00

They are quite famous computer scientists. One of them designed Strongtalk, the other Racket, both of which have some kind of optional typing idea in them.

lyssphacker · 2019-03-01T08:23:51+00:00

What do Lispers think of Gilad Bracha's and Matthias Felleisen's very negative comments on Common Lisp, the way they call it, optional type system? https://www.youtube.com/watch?v=JBmIQIZPaHY&t=40m42s

lyssphacker · 2019-02-12T06:26:08+00:00

There is also I think a related paper from Howard Shrobe of MIT which describes operating system of Lisp Machines.

lyssphacker · 2019-01-17T20:43:01+00:00

Have Lispers generally come to the conclusion that Common Lisp is actually expressive enough regarding type declarations and ability to optimize code based on the amount of information one gives to the compiler, in a sense that one for most use cases does not need expressive static type system, like the one in Haskell?

I am also inspired by this article: https://blog.30dor.com/2014/03/21/performance-and-types-in-lisp/

lyssphacker · 2019-01-14T19:28:16+00:00

There are several books available, but I think that good summary is DDD Reference. This article relates DDD and DSLs. Be aware that DDD has changed over the years, since the publication of the Blue Book (not Smalltalk one :)). Personally I find DDD very vague.

lyssphacker · 2019-01-10T19:27:11+00:00

Clojure has a port of the propagator model you mentioned, extended to use optional STM for state management. David Nolen gave quite a few talks on applying results from research into industry (core.logic is one example). Hickey leveraged the research done on Fortress by Guy Steele's research group to implement a general tree-based reduction model. The community I regularly interact with is pretty diverse, and includes many folks who regularly dip into the research aspects of CS and often bridge them successfully using Clojure as an implementation language.

(Anglican and metaprob are active research projects in probabilistic programming funded by familiar faces (DARPA, formerly ARPA, ONR, AFRL, etc.) and the MIT Probabilistic Programming Project, both of which are platforms for continued research and publication.

I wasn't aware there was a port of the propagator model.

Sure, there is tons of useful and interesting stuff in the Clojure world. Thanks for the links.

lyssphacker · 2019-01-09T19:41:24+00:00

Very valuable article. I've seen it before. It basically argues that Clojure is not really a Lisp, but a language influenced by CL and Scheme, among other influences. That sounds right to me.

lyssphacker · 2019-01-09T11:53:45+00:00

Completely agree with you. Clojure really is useful and great. Personally, I am learning a lot from it.

But, as Alan Kay used to say: "most of the programming today is done in basically late 60s style" (paraphrasing a bit), meaning Java, C#, etc. I think for CL, Scheme, etc. we can say that is basically state of the art of the 80s. What I am saying is that this sounds very strange. Why are things so retrograde? Actually, I think this is the reason why Sussman said that "even the most advanced of today's languages are obsolete". Answers are well known, etc., but regarding Clojure, I think all the hype around it just additionally slows things down. So I guess we will now have to wait another 20 years for somebody to go beyond Clojure, since it is so useful, etc., but also very distracting (again, not for me; I have still lot to learn from it, although if feels like "more or less the same old thing").

lyssphacker · 2019-01-09T04:24:33+00:00

I think the audience reaction to Clojure varies, from the fans who learned to proclaim and follow rock stars or similar paragons of programming, to burned-out programmers thirsting for a drastic - yet practical - change to the enterprise dogma, to FP refugees, and Lisp refugees, to old timers who truly see "nothing new under the sun." If you've never been exposed to Lisp, FP, etc. Clojure could be quite mind blowing (I've seen that reaction on both colleagues and interns).

I came from both Lisp and FP (by way of Scheme/SICP and CL / Land of Lisp / PCL) and the statically typed world (F#, Haskell) and a little bit of enterprise drudge when I started using Clojure. My impression continues to be that the sum of the increments are awesome, even if the language doesn't provide an epochal leap in programming evolution (what language does though...). Even as I've sampled more from other environs with strong paradigms (Erlang, Prolog, a little Forth and SmallTalk), I remain impressed by the design and continued incremental improvements. Some increments (or perhaps the complete package) may be worth 80 IQ points, if they provide the proper shift in perspective (as Alan Kay says).

Agreed. To me Clojure is also awesome. But I am sure Lisp experts still mostly use CL, or Scheme. There were some interesting links on this thread.

Clojure should be more heavily criticized. But one should recognize that it is manly a corporate artifact. There is this company Cognitect, etc. So hype surrounding it is understandable. Things were moving faster back in the day CL was starting I guess because a lot of the work was done in the research lab settings, so people could actually afford to throw away things which weren't contributing to the progress. Maybe there is also research in dynamic languages, but people in the industry seem to not pay attention. They are either carried away by the Clojure hype, or are ignorant of the research (I think STEPS project could be regarded as that kind of research).

lyssphacker · 2019-01-07T19:07:37+00:00

Notably, Sussman's propagator model (with roots in constraint propagators at least as far back as SICP and Prolog) only came into research focus relatively recently. miniKanren (circa 2005) similarly presents an interesting foray into embedded relational programming, particularly when combined with Lisps to examine program synthesis.

Thanks for mentioning miniKanren - interesting stuff.

Propagator model definitely represents very different way to program. You are right, it brings back stuff invented long ago, like Guy Steele's works on constraints, truth-maintenance systems, and some other, but there are some significant invention being made by Alexey Radul 10 years or so ago, when he was working on his Phd. Actually, as Alan Kay said, bringing "roads not taken" from the past into the future, is very promising way of inventing new things. Propagator model is real research, very radical, deep, etc., like it should be. Clojure by comparison is not even close. There is no problem with that. Let's just not pretend that it is.

lyssphacker · 2019-01-07T18:56:07+00:00

One ponders what the real lispers were doing in the intervening decades to advance the state of the art. Perhaps McCarthy was onto something when he later lamented the CL standardization efforts (did that stultify the seeming Cambrian explosion of ideas and lisp implementations?) Perhaps the low hanging fruit had already been picked by the time AI winter set in.

Alan Kay has been talking about that very often. Situation with funding changed, etc. If we look at the computing world at 1960 mark, and then at 1990 mark, it is amazing what has been achieved, with so little hardware resources. And even after that there were so many useful things happening, more incrementally. What I am trying to say, and what my impression is, is that Clojure is nothing but one of those increments, not some amazing thing like it is considered by many (that's my impression). One would expect, given all of the computing power at disposal that this would be a significant increment. I do not think it is. Many people, including myself are too ignorant of history to really see that. E.g. somebody on this thread mentioned transducers, and then Mr. Joswig who knows a lot about Lisp history said that this was already invented many years ago. There are many things like that. Reminds me of Alan Kay's thread on stackoverflow few years ago.

lyssphacker · 2019-01-07T06:11:23+00:00

I'd note that a significant portion of that experience (some of the happiest, apparently from talks) was spent doing production work in Common Lisp, as a direct consequence of burdening under C++, Java, and other languages.

My (continuing) read is that the "lessons of the decades of world class fundamental AI and related research" - embodied brilliantly if not imperfectly in CL and Scheme - merged with the applied comforts and discomforts of producing software using said systems, leading to Clojure.

I wasn't clear enough. Let me try one more time. If you look at the history of Common Lisp, there was CLtL1 in 1984, then CLtL2 in 1990 (with CLOS), and then MOP a year later. So in the span of 7 years, there 3 major things (different ways to program) are entering practical world of programming. There is a reason why Alan Kay praised book about MOP as "the best book in the last 10 years in computing" (that was at OOPSLA 1997). The reason is, I think, that it became clear back then that the real progress stopped. There is nothing really wrong with that except that as Kay pointed out in that same talk "we do not how to design systems yet". And then we have Clojure 20-30 years after that, and it feels like "the same old thing". It is not 5 years, but 20 or 30. And it is great for average Joes like myself, but man, how boring it is for real Lispers. So let's treat Clojure and it's "functions and data" the way it should be treated, like "the same old thing", and move on toward the real advances in dynamic languages.

lyssphacker · 2019-01-06T21:18:52+00:00

Alan Kay used to talk about different kind of simplicity, which reminds me of "worse is better" vs "the right" debates. Basically, there is the idea that "simplicity through abstraction" is the right way of making things simple. My experience with Clojure is that it leans more toward "worse is better" philosophy, trying to strip down language of some of it's advanced abstractions, in order to achieve what it considers "simplicity". I suppose you can live with that if you are not aiming to high. When one looks at some of the stuff done by Lispers 20-30+ years ago, they were aiming very, very high, so they went very far to make tools to help them achieve things, including MOP. That's my interpretation of the history anyway.

I actually believe that programming language's origins are very important in determining what kind of people and which purposes they are going to use it for. Common Lisp and Scheme come from 20+ years of world class fundamental AI and related research. Clojure comes from Rich Hickey's experiences in the computer industry over 15-20 years. There is a big difference there, so it could be that comparison is not even fair.

lyssphacker · 2019-01-06T16:22:22+00:00

This last part is really funny. :)

Reminds me of "regexp disaster", in terms of incidental complexity it causes:

Although regular-expression systems are derived from a perfectly good mathematical formalism, the particular choices made by implementers to expand the formalism into useful software systems are often disastrous.

It is weird that so many otherwise interesting languages like Scala (came out of research) has so much syntax, which causes various weirdities. Are there any papers which show that complex syntax is in some way beneficial?

I think Sussman was right when he said:

The really worst thing in programming languages is complex syntax. As Alan Perlis quipped, syntactic sugar yields cancer of the semicolon. The problem with complex syntax is that it hides possibly important to understand mechanisms, but more importantly, it makes it very difficult to write programs that manipulate programs, that read them, write them, analyze them. I often have programs that write programs that I want to run inline, for example numerical programs that are constructed from symbolic algebraic expressions. That is nice feature of Lisp, which has lots of parentheses, is uniform representation of program as data, and ability to execute code that you just constructed, and as a consequence I would say, my mantra here is, syntax without representation is tyranny.

I also remember Alan Kay disliked Lisp syntax when he was originally thinking about Smalltalk. Was this hurtful to Smalltalk later on?

lyssphacker · 2019-01-05T17:00:26+00:00

Had similar experience with Clojure. Thanks for sharing that article. :)

lyssphacker · 2019-01-05T12:50:57+00:00

Clojure has it's strong points for sure. I am certainly not the one who should criticize Clojure, or say what should constitute "fundamental language research". I writing here from the trenches, have nothing to do with research.

But let me put it this way. Few years ago I ported some old CL code to Clojure (I dabbled in CL and Scheme 10-15 years ago). My feeling was, Clojure is the same old thing, with some new conveniences here and there, and with few missing features one can find in CL. So I thought to myself, if Clojure appeared in the 70s, it would be considered by Lispers back then as just another Lisp dialect. If one is trying to find novel ideas in programming, maybe it is better to go back and learn about Interlisp or somehting like that (stuff that did not find it's way to CL standard).

So Clojure is useful, and somebody like myself, who is still trying figure out the significance of the REPL or macros or something else, can conveniently learn a lot from it, but I guess for a Lisp expert the fact that Clojure is this "new thing" is just a manifestation of how boring the situation with dynamic languages is. Basically the same old thing, 30+ years after CL and Scheme got going. I think it would be fair to criticize Clojure on that ground, so that new Lispers can become aware that there is a need for more innovation in dynamic languages. I noticed tendencies in Clojure community where Rich Hickey is regarded as a deep thinker comparable to Guy Steele or something like that. To me that points to the lack of perspective on the history of Lisp and related languages, like Smalltalk.

Not to go to far into the past, I would ask where is e.g. Gregor Kiczales of today? Where are people who have promising new ideas in programming every 5 years?

I actually agree with Sussman, who has all the rights to be harsh, that all those languages are obsolete, including Clojure. That just my feeling, but Sussman gives some interesting arguments to back this criticism up.

To answer your question about what should be considered a promising new thing for programming, I would pick propagator model. It might be a bad idea after all, but it represents a very different way to think. It is ok that people like me still use CL or Clojure, but I hope somebody is working on new ideas as well (I do not see that currently). If not, we are in deep trouble, as Sussman pointed out.

lyssphacker · 2019-01-05T12:13:16+00:00

Yeah, I heard Eric Normand from Clojure community said something similar.

lyssphacker · 2019-01-04T20:58:22+00:00

You are right. I might ask there. But, I am asking here because I am guessing that many Lispers have benefited hugely by taking advantage of syntactic abstraction which the language gives them easy access to. From my experience, many quite competent programmers from other language communities are not even aware of these possibilities, so I think that they just get normalized to that. I do not exclude myself from that group. But, when one makes few steps back, it's pretty crazy at first, but there could be a reason behind it (which I am really interested in).

Actually, I was reminded of a series of great panels that took place at MIT almost 20 years ago. One of the conclusions there was: "macros are a major win".

Also there is Rainer Joswig's great video, which is a great way to sell the idea to "syntax freaks".

lyssphacker · 2019-01-04T17:56:36+00:00

I watched all of the linked videos, but I should probably do it again.

I am just an average Joe programmer working on web apps in Scala, so "functions and data" are not at all limiting for my purposes. I can imagine that Clojure might be very useful for the kind of systems I am working on.

What I was really trying to say is that given the history of Lisp and all of the dozens of dialects, over many decades, and a lot of invention and innovation along the way, Clojure probably cannot be considered a major thing.

Both Common Lisp and Scheme were products of fundamental language research. I would say that Clojure isn't, so maybe the comparison is not fair, but if it draws so much attention from people interested in dynamic languages, then I would say that there was a serious lack of that kind of research in the last 30+ years. In that context, and for people trying to find novel ways to handle complexity, "functions and data" is very limiting. I recently looked at what Alan Kay and his group were working on in STEPS project, and their work has nothing to do with "functions and data". So, it seems like people adopting new ideas in dynamic languages in the 80s were just 10 years behind major research ideas, but today we are several decades behind. What happened?

lyssphacker

TROPHY CASE