code.diiq

Leaking II

Sat, 08 Oct 2011 10:00:00 -0400

Kartik Agaram pointed out that I haven’t mentioned what happens during the assignment of pre-declared variables in scope.

Here are a few scenarios. This first example signals an error, because a has no binding when print a is called:

def foo (b):
   a ← b

foo 15
print a

This example prints 15:

a ← 5
def foo (b):
   a ← b

foo 15
print a

Which seems acceptable —- but this also prints 15: def foo (b): a ← b

a ← 5
foo 15
print a

This is a behavior that, while not inconsistent or incomprehensible, does prevent the encapsulation of arbitrary code in a scope. I have decided that I want to hold to this maxim:

Any arbitrary call made inside an otherwise empty procedure should have no side effects lasting beyond the end of the wrapping procedure.

Which is to say:

def foo ():
    (some-function)

(foo)

must not change the global scope. This isn’t the case for any lisp that I know of —- it would cause significant problems:

(define (inc-er)
    (let (a 0)
        (lambda () (set! a (+ a 1)))))

Tricks like this counter would no longer work —- the set! called (in an otherwise empty lambda) could have no effect on the value of a. (And even if you allow it to affect its own personal a, there are many reasons to have multiple functions all using the same closed values. It’s a common lisp pattern.) Lisp survives by having both let (no side effects) and set (side effects as discussed above).

I want to eliminate let from my language’s vocabulary —- it causes unnecessary proliferation of indentation and the creation of scopes without semantic meaning. The let in inc-er causes a scope to be created, by way of function call, but that function has no meaningful purpose except to mark the time during which a exists. Procedures should be created based on what they do and what they return, not merely to piggy-back on their scope.

So, there must be some way to declare that you intend to let some side effects escape from a procedure. My current intention is to use leak to do so:

def inc-er ():
    a ← 0
    λ(): 
        leak a
        a ← a + 1

That is: assignment has NO effect outside the current scope unless the particular symbol being assigned has previously been leaked from that scope.

This is NOT a delightful solution —- it is longer and less pleasant than the scheme version, and leak would rapidly become repetitive to write; repetition is what we have computers for. There is no clear way to abstract leak using f-exprs; currently Oyster doesn’t use true macros. So I am unsure if this is a final answer, but it does satisfy my maxim while still entertaining the closure-magic that makes scheme so pleasurable.

Leaking I

Thu, 06 Oct 2011 21:26:00 -0400

I’m designing a programming language called Tainted Oyster.

One thing I have to think about is how to set a variable in the current scope. The easy way is the straightforward way:

a ← 25

This pairs the value 25 with the symbol a, in the scope in which it’s written. (The cheap way to say that is, “Now a is 25.” Unfortunately, I’m kinda slow, and when I’m directly discussing the value bound to the same symbol in different scopes, little lies like “is” often trap me.)

But I want to be able to abstract-ify assignment; for instance, in writing the procedure def. def creates a function and assigns it to a symbol in the current scope:

def fib (val):
    if (val <= 0):
        1
        val + fib (val - 1)

For the moment, though, let me stick to a simpler example. Here’s the skeleton of a function that tries to set a to 5 times a number:

def set-a-to-5-times (b):
    # do some things

set-a-to-5-times 6
# now a == 30

What should go in the place of the comment do some things? There are two possibilities that I have experienced. Some languages work this way: if the symbol you are assigning has not already been declared in the current scope, then it will be assigned in the global scope. Javascript works this way. This, I will put forward, is balderdash. It is foul because it prevents you from wrapping an unknown block of code in a scope in order to isolate it.

The other option is that you can only set variables inside the current scope. This is a neat, functional approach, that is easy to reason about —— but it lacks the power to write set-a-to-5-times at all.

Oyster takes this tack: normally, scopes encapsulate completely —- like the second option. But scopes can have holes explicitly poked in them. I call a hole a “leak”, and use a procedure called leak. leak with one argument does just what I need:

def set-a-to-5-times (b):
    leak a
    a ← 5 * b

set-a-to-5-times 6
print a                  # prints 30

Here, leak pokes an a-shaped hole in foo’s scope, and lets the assignment act as if it were one level up. Without leak, the print statement would signal an error, due to an unbound symbol a.

That’s leaking (with one argument).

Programmers think differently than non-programmers.

Sat, 15 Jan 2011 12:26:00 -0500

Singers think differently than non-singers

Stuffed animal enthusiasts think differently than non-enthusiasts

Jacques Mattehij wrote a post [here] about the way programmers think. He argues that programmers are analytical, but so are scientists; programmers are logical, but so are mathematicians; programmers are obsessive, but so are artists (he says scientists again, but I like this example better).

Anyone can learn to program, Jacques points out, so programmers are surely not born thinking differently than the rest of the world. I completely agree.

Therefore, he concludes, programmers think no differently than non-programmers. That’s absurd.

His unstated assumption, I suspect, is that you will always think the way you thought when you were born. Thank god that is not true; babies are selfish, boring little bastards that think you disappear when you’re behind a blanket. Learning to program changes the way you think, along with learning Italian, learning to draw, and learning to figure skate. That’s what learning is: a change in the way you think and behave.

I am an artist and a programmer. Other artists have said to me in aggravation, “It’s a canvas, not a computer. It doesn’t have to make sense.” I continue to paint using the cognitive tools programming has given me; I suspect the other artists are wrong. Those artists are capable of logical thought. It would be silly to think otherwise. The way they think about logic is different however, as are the times they decide to use it consciously.

Similarly, I program slowly, because I am obsessive about the aesthetics of my code. “Just make it work,” other coders say, and I try to speed up — but I yearn for the same feeling of intuitive ‘rightness’ from my code as from my art. Those other programmers are capable of recognizing beauty, but they strive for beauty at different times and in different ways.

I would be a different person, and a different artist, if I did not program.

I would be a different person, and a different programmer, if I did not make art.

The habits, analogies, and problem-solving strategies of different fields are different. That should not be a surprise. They sometimes overlap, and the more you learn, the more your mental tools leak from one field to another — and that is a good thing.

This is the obvious corollary to Sapir-Whorf: learning anything changes the way you think.

WhiteProxy

Thu, 13 Jan 2011 23:22:00 -0500

I get distracted very easily, and when I am looking up something important, I don’t like spending my willpower avoiding distractions: facebook, my email, comics, youtube, twitter —— all the ten-thousand things.

What could I do? I wrote a little proxy server that block all content unrelated to the task at hand. It even takes the time to look up related words, so that it won’t block anything important. It also only gives me ten minutes of access —- plenty of time to open some documentation, not enough time to open 50 tabs of vaguely related journal articles.

I don’t recommend using this all the time —- sometimes free association hyperlinking is very valuable —- but when the job needs doing, I don’t need distracting. So I threw together WhiteProxy.