Something I wrote In my Lojban days…

doi .iu cmaxi'a
lo li’i pendo cu se retpei mi
pu’o lo mi'o mafkai nunpenmi .i'i
  manci litru
  zdile .ui
  melbi pacna
  tsali .ia .a'i
  simxu xendo
  frili .ijebo
lo makfa roda mulgau .uo
(.ie) doi .iu cmaxi'a
ju’o do mi sinma traji pendo〜

A translation of the MLP:FiM opening.

In spite of our “right” ideas…

You know that Galileo Galilei in 1633 allegedly said “eppur si muove”, “and yet it moves”, after recanting before the Inquisition his theory that the earth moves around the sun. Now, I claim that today this phrase is used in a totally misleading way. It is used in a naïve empiricist way as if, “yeah, yeah, you may deny it, but in reality it still goes on”, as a naïve empiricist assertion of reality which persists (eppur si muove, nonetheless it moves in spite of our wrong ideas). I claim that it would have been much more interesting and appropriate to our situation to read this eppur si muove in a, again, much more intelligent, opposite way, which is hinted at in Marx’s theory of commodity fetishism, where eppur si muove means something can be denounced as untrue, nonexisting, etc… but eppur si muove, it nonetheless functions as ideology, it still moves you. Like, this is today’s cynicism: you don’t believe in God, but God still moves you. It is demonstrated that something is wrong, but it still functions. This is, I think, a much more interesting version of eppur si muove.

Slavoj Žižek, The Idea of Communism and its Actuality / [my transcription]


Floras ĉerizujo monta,
kaj printempo foren pretas.
Ĉe mi estas ĉio sama,
krom ke mi ne plu ĉeestas.

Jam verdiĝas vinberujo,
ĉirkaŭ domteraso olda.
Ĉio samas kiel iam,
krom ke mi ne plu ĉeestas…
Haskell-style curry function in Scheme

#lang racket

(define (>curry f . n-opt)
  (let loop ((final-args '()) 
             (n (if (empty? n-opt) 2 (car n-opt))))
    (if (zero? n)
        (apply f final-args)
        (lambda nth-args
          (loop (append final-args nth-args) (sub1 n))))))

(>curry list 0)                      ;=> '() ;; should this case really be…
((>curry list 1) 'a)                 ;=> '(a)
(((>curry list) 'a 'b 'c) 'd 'e 'f)  ;=> '(a b c d e f)
((((>curry list 3) 'a 1) 'b 2) 'c 3) ;=> '(a 1 b 2 c 3)

(define (curry< f . n-opt)
  (let loop ((final-args '()) 
             (n (if (empty? n-opt) 2 (car n-opt))))
    (if (zero? n)
        (apply f final-args)
        (lambda nth-args
          (loop (append nth-args final-args) (sub1 n))))))

(curry< list 0)                      ;=> '() ;; …part of the interface, though?
((curry< list 1) 'a)                 ;=> '(a)
(((curry< list) 'a 'b 'c) 'd 'e 'f)  ;=> '(d e f a b c)
((((curry< list 3) 'a 1) 'b 2) 'c 3) ;=> '(c 3 b 2 a 1)
INTERMISSION

INTERMISSION

Gender-neutral Pronoun Proposal

Short story: Lojban's acronym pro-sumti, appropriated for English.

Elaboration: Whenever you see a lone letter (or acronym) used as a pronoun, it refers to the closest (or most contextually obvious) noun phrase that begins with it (or matches it acronym-wise). I leave details such as whether it’s capitalized or ends with a period as stylistic choices for the author at this point—’cause, hey, this linguistic experiment is arguably even more avant-garde than zie/hir/ey ;).

Some examples:

  • "I have a friend who wants me to tell you that f likes your shoes."
  • "Every person knows p’s own limits."
  • "Leslie has a dog but L likes cats too."
  • “A queer has two options available to q: stop being queer, or live as a warrior.”src

You may already be gagging at how machine-like or alien this scheme looks. I’m pretty sure such words were at one point directed at the source language. Well, I would only fault you for not giving it enough time for it to settle in, because compared to zie/hir/ey, it does demonstrate some advantages. Most prominently, (a) the pronouns are mnemonic, which helps in distinguishing two things of the same gender, in the average case where they don’t begin with the same letter, and (b) the pronouns are gender-neutral in a metalinguistic sense, in that they were not constructed in analogy to gendered pronouns.

Historical aside: In fact, Lojban has inherited this feature from its Old form, Loglan.


While the purpose of gender-neutral pronouns is arguably to enable greater self-expression, my thinking has led me upon a form of self-expression with which Lojban deals poorly: arbitrary coinage. Lojban’s root words (gismu) are a truly privileged class of words. (For one thing, I am unable to call Lojban a culturally neutral language as long as cultural gismu exist.) The managed growth of the gismu set is directly tied to Lojban’s tenet of tractable unambiguity, which sets the pretext for why resistance to naturalism is such an undying component of the Lojbanic spirit.

The preferred form of making loan words is type 3 fu’ivla, a mechanism which, while it works with almost no interference to the rest of the language, is about as clunky as saying “felis catus” instead of “cat”. However, type 4 fu’ivla provide a somewhat more naturalistic way of creating arbitrary words, with a flavour not unlike much of Finnegans Wake ;). Now, I really want to like type 4 fu’ivla, but the Lojban community’s animosity towards them is staggering. The attitude is sadly quite understandable, given Lojban’s current configuration, meaning that there is a certain point along the line of natural language likeness after which Lojban would gradually lose its identifying features.

I envision a hypothetical where the Lojban-speaking population grows faster than L education does. Consequently the language bifurcates into a formal/classical/clerical dialect, a form of the language which we know today, and an informal/vulgar/popular dialect, which abandons many of the strictures of the former whose sole purpose is disambiguation and machine-parseability, preferring to establish a conventional reading for most sentences (as with most natural languages).

At the end of the day, as can be said for many things in life, sometimes it’s better to just shut up and learn the language, a potentially enriching experience, in spite of the looming sense of incompleteness.

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)

The Clojure Dynasty

(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)

Renaissance

Pastward from here lies this site’s previous life. It was a humble tumblelog which served as a way to share links and videos with my friends during high school. I launched it early enough that I was even able to grab a Tumblr URL which matches my name this conveniently. 

However, as time passed I mostly abandoned this kind of link sharing. I increasingly felt the need to publish my thoughts in more rigorous forms than Twitter and Facebook allowed.

And so now this site will be repurposed into a blog. I intend to focus it on insights I have unexpectedly come upon: expect some computer science, programming language design, and so on. Bear with me as I am a complete novice in those subjects, and still have a lot of the literature ahead of me. Nevertheless, I will share the half-baked ideas I reached (and, who knows, they might even be of interest to the hypothetical reader of this blog). 

So… I’ll be off looking for an Emacs interface to Tumblr now…

(I’m uros643 on Hacker News, by the way)