I'm a computer science student, programming language design
enthusiast, and occasional linguist/conlanger. mi'e Uroš Dimitrijević
Posts tagged: lisp
All systems are defenceless against actions at a level which is sufficiently meta. However most threats happen at a level where systems are given a reasonable chance to defend themselves. Here it becomes obvious that some systems are better than others at ensuring their own stability. Hence, instead of giving up on security (because there is always a level at which it is unsustainable), we should strive to create systems which not only provide a sane experience, but which also try to minimize the abuse of authority.
Smalltalk and Common Lisp may indeed be cool reflective environments, but it is undeniably the case that they do not provide adequate security if we wish to elevate them to operating system status. For further discussion, see SmalltalkSecurity. This problem is, at its most optimistic, a reason to improve the family tree. Newspeak is a great start. (Clojure not so much, but it has never claimed to be an acceptable Lisp Machine system language).
(Stanislav Datskovskiy should really consider fixing the comment section of his blog)
(This was written as a response to Of Weighty Matters, or Thumbs Still Down for Clojure)
I hear ya. Clojure’s Lisp nature is currently bounded by the JVM’s. Its primitives are not designed for environments as living and breathing as Genera. The hype surrounding Clojure is strong enough to attract programmers who are not necessarily imbued with a sense of the history of Computing, much less of Lisp and its heritage. Clojure prides itself on its practicality.
But really, the size of a language’s standard library is a red herring. I think the kicker in Arcane’s blog post is that this is a social matter. Clojure will be perceived as lighter, more nimble than CL even if/when it surpasses it in standard library size. It’s essentially an unexamined prejudice that has unfortunately settled in the wider programming community (similar to stereotypes which coincide with absence of reflection in society at large).
Clojure obviously has an easier time attracting positive attention compared to CL, especially in light of the “rockstar”/”hipster”/”awesome” rhetoric that has helped some technologies gain mindshare this past decade. CL carries too much cultural baggage to be perceived as innocently as the fledgling. It doesn’t really hurt either that Clojure backs contemporary lobbies such as concurrency and functional programming.
I think, if there’s anything it should be praised for, it’s that Clojure is not only a language which wants to be used, but that it wants to drag a part of Lisp with it. Clojure is an evolutionary step for the mainstream acceptance of Lisp. It’s easy for the old guard to dismiss it as unnecessarily revolutionary in its rejection of the traditional bloodline, but Lisp really needed a clean break in order to push its ideas into the spotlight anew.
In due time, the rest will be rediscovered (and hopefully surpassed).
#lang racket
;; This defines an n-argument version of the Y combinator. A use case is
;; implementing mutually recursive functions. The intended usage is:
;; ((y* (lambda (f1 f2 ... fn) (lambda <body of f1>))
;; (lambda (f1 f2 ... fn) (lambda <body of f2>))
;; ...
;; (lambda (f1 f2 ... fn) (lambda <body of fn>)))
;; (lambda (f1 f2 ... fn) <use of f1 to fn>))
;; Implementation:
(define u (lambda (f) (f f))) ;trusty old Mockingbird
(define y*
(lambda fs
(u (lambda (this)
(lambda (receiver)
(apply receiver
(map (lambda (f)
(lambda args
(apply ((u this) f) args)))
fs)))))))
;; An application: mutually recursive odd?/even? predicates
((y* (lambda (oddp evenp) (lambda (n) (if (zero? n) #f (evenp (sub1 n)))))
(lambda (oddp evenp) (lambda (n) (if (zero? n) #t (oddp (sub1 n))))))
(lambda (oddp evenp)
(list (oddp 5) (oddp 6) (evenp 7) (evenp 8))))
;; produces '(#t #f #f #t)
