Probably Programming

Well, this is embarrassing.

Mon, 28 Sep 2015 00:00:00 +0000

Well, it turns out it’s been over 4 years since I last wrote a blog post. Whoops. Pretty much the entire time I’ve been occasionally telling myself “Oh yeah, I should start writing blog posts again.”

Well, here we go. Yet another “I’m still alive” post. If you’re wondering what I’ve been doing, I recommend taking a look at the title of the site. After realizing I didn’t have enough savings to try to launch a product I took another job which ended up taking up all of my time and nearly killing myself with stress. After about a year at that job, I quit to join a small startup called Whoosh Traffic. A bit more than a year later, a while after “graduating” from the first Techstars Austin class, Whoosh Traffic failed and just as I was about to miss a paycheck, OwnLocal acquired Whoosh and I was brought on to help integrate the Whoosh software into OwnLocal’s stack.

OwnLocal encourages a healthy work-life balance, and so I’ve actually started to have some amount of free time for the first time in years and I’ve started to want to actually use that free time for personal projects again instead of just playing video games (hey, it’s not called “Definitely Programming”), including this blog.

As with most things, the hardest part for me is just getting started, so here I go…

sated: a Programmer's Editor for you

Sun, 20 Mar 2011 00:00:00 +0000

Update (2015-09-28): I am no longer working on sated. A short while after writing this post I ended up taking a job which involved working on a text editor and so continuing work on sated would have been a conflict of interests (and potentially caused my work on sated to be the property of my employer at the time). So I stopped working on sated, and now here I am, three jobs later, and I’ve started using Atom, and while it’s not exactly what I had in mind for sated, it is close enough that I’ve stopped using Emacs and I don’t really have any plans to start up work on sated again.

I have begun work on sated, a lightweight, extensible, cross-platform text editor for programmers.

I’m taking a “lean startup” approach to this, and so I’m approaching this as a small commercial venture. Currently, I am at an extremely early stage of both software and business development. How early? Well, right now, it’s just me, an iteration’s worth of tasks in Pivotal Tracker, and a single landing page.

sated is for you, programmer

sated is going to start as a basic core which only allows for two things:

Editing text files.
Extending sated.

This makes for a very natural Minimum Viable Product. Essentially, I will have a simple framework for building a text editor, and power users will have a way to get the editing experience which they want by writing code to customize their copy of sated.

Not everyone is a power user, of course, so the next step will be to create optional modules which can be plugged in to the core editor, ideally as easily as possible. Which modules get created will depend on what feedback I get from users.

One more key component I mentioned above is that sated will be “cross-platform”. Many of the popular text editors out there today only run on a single platform, which means that some users are forced to switch to a different editor when they go from Windows to OS X to Linux. By targeting all three platforms, users will be able to use the same editor anywhere they go, perhaps even carrying a flash drive with all three builds and their favorite plug-ins, so they can edit in comfort even on computers which aren’t theirs.

Why this is viable

I know that there is a market for commercial programmer’s editors, considering the continued existence of products like TextMate, UltraEdit, the E Text Editor and others.

I also know that a large number of users don’t pay for their text editor; editors like Emacs and VIM both have huge followings, as do several more “modern” free editors.

The problem with most commercial editors is that they generally only run on a single platform, or that they are not as customizable as a user might like.

The problem with most free editors is that they are extensions of decades-old designs (Emacs and vi were both released in 1976), or they are relatively new but designed with a more fixed set of features in mind, or at the very least are difficult to extend. Emacs and VIM can be customized nearly endlessly, but you have to deal with all the cruft and eccentricities of their respective architectures.

With sated, I’m starting with extensibility in mind, but also simplicity. Those users who just want to try out an extension shouldn’t have to open up a configuration file and edit it by hand. However, users who want to will still be able to.

Programmers tend to be busy people, and plenty of them have demonstrated that it’s worth it to them to pay for someone else to give them a good editor to work with. I’m confident that if I can make an editor which is better in at least some way, that developers who have more important things to do with their time will be willing to pay for it.

How I’m planning on making money

There are a few possibilities I’m considering for revenue streams. In true lean fashion I am not going to lock myself into only one way of doing things.

The simplest and most straightforward idea is to take the same approach as other commercial editors: just sell the editor, with all its bundled features, for a fixed price.

Another alternative is to take an “app store” approach: sell the core editor for a low price (or even give it away for free), but then have bundles of functionality which are available for purchase, each for a relatively small price.

The app store approach also could have the benefit of eventually allowing third parties to develop their own extensions and sell them in the app store as well. There could be an interface in the editor to find and purchase plug-ins for feature you might need.

To start with, I think I will take the single-price route, just because it’s simpler, both for me to implement and for users to know what they are paying for. Version 1.0 will most likely be somewhere in the $50 range, since that seems to be the standard price point in the text editor market.

How I got here

I found out recently that at the end of March, I will find myself unemployed for the first time in nearly 4 years, but rather than immediately trying to find a new job, I decided that it was time to try and start a business of my own. Soon after making that decision, I was helped along by discovering AppSumo’s Lean Startup Bundle for SXSW, and that was all the motivation I needed to get started.

For the next two months, my wife and I are living off of savings while I work full time at getting sated off the ground. Two months is a lot less time than people usually give themselves for this sort of thing, but I plan on counting the time to my first release in weeks, not months, and doing so on one hand.

Not only has this bundle gotten me ~$6000 worth of stuff and services for $99, it has also saved me the trouble of going out and finding each of these services on my own. It’s fully possible that I may decide some of them are not for me, but at least I’m not wasting time now trying to decide that.

Here’s what I’ve done so far with the bundle:

Set up my Pivotal Tracker account and filled in my first iteration’s-worth of tasks (the basic editor).
Set up SnapEngage on my sated landing page. If you want to talk to me about sated (in a live chat, or via email), you can go there and do so right now.
Set up a UserVoice page where people can tell me what features they want to see in sated. Do you have a feature you can’t live without in a text editor? Let me know!.
Set up Crazy Egg tracking on my sated landing page.
Redeemed my 25,000-email credit from Postmark, in preparation for the future need to send emails to customers.
Started through “Running Lean” and created my first Lean Canvas. I love the idea of a business plan on a single page.
Grabbed my copies of The Venture Hacks Bible, Andrew Chen’s and Sean Ellis’s ebooks, and have read some of each. That’s a lot of stuff to read!
Signed up for Udemy “Startup and Go” course and started my way through. I have concluded that Adeo Ressi likes to curse a lot.
Signed up for my 3 months of Hacker Monthly.
Signed up for my copy of Eric Ries’ “The Lean Startup”. I’ve been following Eric’s blog for quite some time now, and I’m excited to read the book as well.
Signed up for and gotten my $200 credit on Chargify. I will test this out once I start taking payments.
Checked out Ask Your Target Market. Thought “hmm, this looks familiar.” Remembered that I wrote the JavaScript for several of their pages (the target demographic and write your survey pages), while working for a previous company.
Started through the LaunchBit startup guide. They seem to be more focused on the non-technical side of things, but so far it has helped with planning from the business side of things.
Checked out Geckoboard, HipChat, Pandaform, Ginzametrics, Kissmetrics, Slidedeck, Saucelabs, Feefighters, uTest, Lessaccounting, 99designs, Batchbook, Textingly, Infochimps, WP Engine, Server Density, Trada, and Zencoder. At the moment I don’t think I really have much use for most of these (except perhaps the metrics sites), but I did sign up with accounts for any of them that didn’t require a credit card up front (all but one, I don’t recall which), in case a need arises in the future.

What’s next

Right now, I have a theory: people will be willing to pay for an editor which will run everywhere and can become the exact editor they want.

My next step is to test that theory.

I’ve already built my first MVP, the sated landing page. It’s not so much an actual product, but a way for me to gauge interest before I even have a product to show.

In between my attempts at getting people to tell me if my idea is worthwhile, I am also going to start building the real MVP: the basic editor itself. This is a bit of a break from the usual lean process, but since it’s only me, the only thing it will cost me is my own time, and at the very worst I’ll end up with an editor that works exactly how I want it to.

If the feeling I get from the feedback I receive isn’t too discouraging, the next step will be to see if people are willing to put their money where their mouth is. Version 0.1 won’t have much to it. It will be extremely basic, but it will have to potential to become exactly the editor a given user wants.

Even still, I can’t in good conscience charge $50 for what is essentially a slightly-improved notepad, so here’s what I’m thinking:

The price for any given release will be set proportionally to how many version 1.0 features are included in that release.
Any customer who purchases a pre-1.0 release will receive any subsequent releases, up to and including version 1.0, for no further charge, as well as a discount on future major releases.
With this in mind, version 0.1 will be released extremely soon, with a price of less than $5. If the price of version 1.0 ends up being $50, that’s a pretty good discount for early adopters…

If you have any questions, comments, suggestions, checks for large sums of money, or anything else you wish to send my way, please get a hold of me via either the “help” button or the “tell me what features” link on the sated landing page.

This post doubles as my entry into the AppSumo Lean Startup Challenge, and will hopefully lead my winning. Of course, I’d love to get one of the top prizes, as that would allow me to continue working on sated full time for much longer than my relatively small amount of savings, but any of the prizes would be invaluable to helping sated become a success.

If nothing else, having a link to this blog post on the contest voting page will gain me some potential customers, and that by itself is worth something.

Comic-Fu

Tue, 09 Feb 2010 18:42:21 +0000

Angie has been slaving away working on Company-Y lately, and I think it’s coming along quite nicely.

Yesterday I decided to give her a break by helping with the coloring of the latest page “I love it when a plan comes together”, and I realized that the coloring process could be greatly sped up if we could simply flood fill the various areas, rather than having to draw around the outline of the area before flood filling it.

The comic is drawn in The GIMP. The lines are drawn on an transparent layer, and then the coloring is done on another layer below, so as not to mess up the lines. Since there are no boundaries on the lower layer, flood filling doesn’t work.

So I tossed together a quick TinyLisp add-on which takes the current layer, duplicates it, thresholds on alpha level (gets rid of any pixels that aren’t within a certain opacity level), and puts the new layer below the current one. After that, flood filling can be done in the lower layer without any issues related to the antialiased/feathered edges of the lines.

It’s a fairly simple script, though it took me a while to get it all working correctly (why the heck do all the GIMP built-ins return lists, making me have to (car …) everywhere, instead of just the primitives?)

Anyway, I was inspired, and came up with some ideas for some more time-saving add-ons to write, so I’ve started a Comic-Fu project at GitHub

If you want to install it, simply download make-fillable.scm and put it into your .gimp-2.6/scripts directory. It should then be in the Filters->Comic-Fu menu the next time you start up the GIMP.

p.s. I’m totally counting this as one of my programs for my 500 Programming Languages thing. I’ll do a write-up of TinyScheme at a later point.

⚃ Rolling Dice with JS and Unicode ⚂

Wed, 06 Jan 2010 22:53:48 +0000

I recently discovered the unicode xscreensaver hack, and have had it running on my secondary monitor for the heck of it. I found out that there are dice face symbols, and I was inspired to do something with them.

So, I made a simple Unicode-dice roller in JavaScript. I know the same thing could be done in JS, but this way you can roll some numbers to paste into Twitter or something, if you feel like it.

Enter number of Dice to roll:

Result:

The code is extremely simple, calling Math.floor on the result of Math.random n times, then using a small table of the codepoints from U+2680 to U+2685 to build a string.

Here is the code for anyone interested:

    <script type="text/javascript">
    function roll(n) {
        var dice = ['\u2680', '\u2681', '\u2682', '\u2683', '\u2684', '\u2685'];
        var results = '';
        for (var i=0; i<n; i++) {
            results += dice[Math.floor(Math.random()*6)] + ' ';
        }
        return results;
    }
    
    function doRoll(countElem, resultElem) {
        document.getElementById(resultElem).innerHTML = 
            roll(parseInt(document.getElementById(countElem).value));
    }
    </script>
    
    Enter number of Dice to roll:<br><input type="text" id="dice-roll-number" />
    <input type="button" onclick="doRoll('dice-roll-number', 'dice-roll-result')" value="Roll!" />
    
    Result: <span style="font-size: 64px; line-height: normal" id="dice-roll-result"></span>

A save your place bookmarklet

Tue, 01 Dec 2009 02:10:38 +0000

(image source)

I read a lot of web comics, and one of the things that happens when reading through the archives of a comic is that I lose my place in the history, so when I come back, I have to spend a lot of time searching to find where I left off.

I wrote this simple set of bookmarklets to help me in this situation. The “save place” bookmarklet stuffs the current URL into a cookie (cookies are per site, so there will be one cookie for each site you use this on), and the “restore place” bookmarklet takes the URL out of the cookie (if it exists) and loads that page. The “clear place” bookmarklet clears the cookie.

To use them, just drag the bookmarklets to your bookmark toolbar, or right-click on them and select “bookmark this link”.

Save Place | Restore Place | Clear Place

For those who are interested, here’s the code in function form:

    function savePlace() {
        var date = new Date();
        document.cookie='ppdc_saved_location='+escape(document.location)
            +'; expires='+date.setTime(date.getTime()+22896000000)+'; path=/';
    }
    
    function restorePlace() {
        document.location = (function() {
             var ca = document.cookie.split(';');
             for(var i=0;i<ca.length;i++) {
                 var c=ca[i];
                 while (c.charAt(0)==' ') c = c.substring(1,c.length);
                 if (c.indexOf('ppdc_saved_location=') == 0) 
                     return unescape(c.substring(20,c.length));
             }
             return document.location;
        })();
    }
    
    function clearPlace() {
        document.cookie='ppdc_saved_location=; expires=-1; path=/';
    }

I based my code off the createCookie and readCookie functions from QuirksMode

Fun with bookmarklets and CSS3 transforms

Thu, 26 Nov 2009 00:52:04 +0000

I recently read about the CSS transform property, and I was inspired to give it a try in a fun and mostly useless way.

After a bit of fidding, I present to you the “Rotate!” bookmarklet (click it several times if it doesn’t work the first time):

Rotate!

Simply drag the above link to your bookmarks toolbar, and whenever you get bored with a webpage, click that link, and see what happens!

The code is pretty simple. It just gets a list of all the divs on the page, picks one of them at random, and starts rotating it. Click it multiple times, and it will rotate multiple times.

Here’s the code, formatted for your viewing pleasure:

    (function() {
      var ds = document.getElementsByTagName('div');
      var d = ds[Math.round(Math.random()*ds.length)];
      function rotateHeaders(r) {
        d.style['WebkitTransform'] = d.style['MozTransform'] = 'rotate(' + r + 'deg)';
        setTimeout(function() {rotateHeaders(++r % 360);}, 100);
      }
      rotateHeaders(1);
    })()

Unfortuneately, this only works in Firefox and Webkit-based browsers at the moment..wait, no, that’s pretty much ok. You IE folks out there are used to things not working in your browser by now.

With a couple small changes, you can make it scale instead: Scale!

A Simple Lisp Parser in Python

Mon, 23 Nov 2009 02:59:15 +0000

A managed to sneak in a little time recently and write a simple Lisp s-expression parser in Python.

I started out with a version that just understands parentheses, atoms, and strings, but it was just a couple of extra lines to add in support for the quote “operator”, that I went ahead and threw that in there, too.

I’ll go ahead and go through it bit-by-bit here, though I think it’s pretty straightforward.

    from string import whitespace
    
    atom_end = set('()"\'') | set(whitespace)

When any of these things are encountered while reading an atom, the atom should be ended. This means no need for whitespace betwen an atom and opening or closing parentheses or quotes.

    def parse(sexp):
        stack, i, length = [[]], 0, len(sexp)
        while i < length:

Rather than write this recursively, I am using a list as a stack and a simple while-loop to go through the contents of the string. I start with an empty list on the stack, which will hold the entire parsed sexp when the parsing is done.

    c = sexp[i]
            reading = type(stack[-1])

Each character is put into c and the type of the current item being read is checked. Rather than using some variable to keep track of the current state of the parser, I just used a distinct Python type for each of the possible lisp types to be read: a list for a list, a string for a string, and a string inside a tuple for an atom. Using this system, I just have to check what type the top element in the stack is, and I’ll know what I’m currently reading.

    if reading == list:
                if   c == '(': stack.append([])
                elif c == ')': 
                    stack[-2].append(stack.pop())
                    if stack[-1][0] == ('quote',): stack[-2].append(stack.pop())
                elif c == '"': stack.append('')
                elif c == "'": stack.append([('quote',)])
                elif c in whitespace: pass
                else: stack.append((c,))

When reading a list:

If an opening parenthesis is encountered, add a new list to the stack
If a closing parenthesis is encountered, take the list from the top of the stack and append it to the next list down in the stack. Check if the last thing read was a quote, and if so, add this list as the parameter to the quote call.
If an opening double-quote is encountered, add an empty string to the stack.
If a single-quote is found, add a list with a quote symbol at the beginning of it.
If c is whitespace, ignore it.
Otherwise, start an atom with whatever other character was found.

    elif reading == str:
                if   c == '"': 
                    stack[-2].append(stack.pop())
                    if stack[-1][0] == ('quote',): stack[-2].append(stack.pop())
                elif c == '\\': 
                    i += 1
                    stack[-1] += sexp[i]
                else: stack[-1] += c

When reading a string:

If a closing double-quote is found, end the string, and check for a previous quote call like above (it doesn’t really make sense to quote a string, but this isn’t really the place to check for that, is it?)
If a backslash is found, put whatever the following character is in the string. This is a simplistic way to at least allow double-quotes to be escaped, but I don’t have anything allowing for more complex escape-strings in here yet.
Anything else, add to the string.

    elif reading == tuple:
                if   c in atom_end: 
                    atom = stack.pop()
                    if atom[0][0].isdigit(): stack[-1].append(eval(atom[0]))
                    else: stack[-1].append(atom)
                    if stack[-1][0] == ('quote',): stack[-2].append(stack.pop())
                    continue
                else: stack[-1] = ((stack[-1][0] + c),)

When reading an atom:

If the end of the atom has been reached, check if the atom is a number (this code just assumes that if the first character of the atom is numeric, that it’s a number). If it is, I cheat and use eval to get its value, if it’s not, I leave the atom as a tuple-wrapped string.
Anything else, add as a character to the atom.

    i += 1
        return stack.pop()

At the end here, I just take whatever’s on top of the stack (which should be the only thing on the stack if a proper s-expression was passed in), and return that.

I’m going to continue working on and improving this parser, for use in another project of mine, so I will be adding more functionality.

I was thinking of doing a s-expression to Python bytecode compiler, but someone already wrote one, and they even took the name I was going to use: sexpy.

I think the first thing I’ll be adding is the capability for the parser to yield sub-sexps so the entire thing doesn’t need to be parsed in one go before returning anything. Another thing I’ll most likely add is some checking for invalid sexps, something I left out for clarity in my initial version.

For those who are interested, here’s the complete version of sexp.py

IE7 Requires type="submit" for

Fri, 30 Oct 2009 18:32:31 +0000

If you don’t specify type=“submit” for a <button> element, IE7 (and probably IE6, too) will do nothing when that button is clicked (well, unless you have an onclick handler on that element, of course).

The W3C HTML standard states that the default for a <button> element should be “submit”, but if you want it to work with IE7 or earlier, you’ll have to be explicit about it.

I lost some precious time on this fun bug. I was doing some form validation via the great jQuery Validation plugin and for some reason, the form wasn’t validation in any IE earlier than IE 8.

Of course, since it’s such a pain to debug IE, I had a heckuva time figuring out the source of the bug, because I just assumed it was some weird JavaScript quirk, and didn’t even consider that it could be something as simple as a “missing” element attribute.

Ah well. Hopefully this will help somebody else avoid the same problem.

Walking Journal: 45 miles, starting a Twitter client chain

Fri, 25 Sep 2009 03:37:22 +0000

I’ve been neglecting both walking and posting on here, though I’ve neglected posting more, obviously.

I’ve been very busy with work and side projects and my house trying to fall apart on me, so I’ve been out of free time lately.

Anyway, my total is now up to 45 miles of walking. Not too much more than last time, really. I’ve gone on some walks around the neighborhood with Angie, and I’m not counting them, mostly because I don’t know how long they are, really.

I decided I wanted to start a “chain,” where every day I do something to work toward a goal I’ve set for myself (yes, I mean other than the walking, though that can be a chain as well).

Fortunately enough for me, I found Don’t Break The Chain, where you can keep track of one or more “chains” of things you want to do every day.

The Twitter Client Chain

So I’m creating a web-based Twitter client, as a project for me to try out all the different techniques and technologies that I want to use, but don’t have the chance to work with as much as I’d like during my day job. Also, ideally, it will at some point become a supplementary source of income.

That’s a quite a way off until I have more free time in a month or two, but for now, I will satisfy myself with making some small amount of progress on it each day (hopefully).

I’m writing this client in Erlang, using the awesome Nitrogen web framework with the equally awesome MochiWeb web server. My goals for this project include using test driven development and continuous deployment and fully embracing the mantra of “release early, release often”.

The plan is to have something up and running on a server as soon as possible. By something, I mean even less than a full-featured twitter client. But as soon as something is up, I can start getting feedback, and see what I should work on next. If I’m creating a product for users, there’s no use in developing what I want.

I need to develop what my users want.

I started this chain up about a week ago, and broke it after the first day. Now I’m trying again.

Tests and pre-commit hooks

During my previous, one-day chain, I managed to get a test harness (using the EUnit Erlang unit test framework) set up which will find any modules ending with _tests, stopping at the first error.

At the moment, I have a shell script which runs the tests. When it starts to take too long, I will switch over to an Erlang module which loops through, so I don’t get the startup times of the Erlang interpreter for each test. Or if anyone knows an easier way (perhaps there’s already a module that does that somewhere?).

    #!/bin/bash
    
    for modfile in `ls ebin/*_tests.beam`
    do
        mod=`basename $modfile .beam`
        echo Running $mod:
        erl -noshell -pa ./ebin -s runtest main ${mod%.*}
        [ $? -eq 0 ] || exit 1
    done
    [ $mod ] || exit 1

The runtest module consists of the following:

    -module(runtest).
    -export([main/1]).
    
    main(Mod) ->
        case eunit:test(Mod) of
            error -> halt(1);
            _ -> init:stop()
        end.

It’s all kind of thrown together, but the point is incremental improvement, so I’ll get back to it when/if I need to. Like I said, there’s probably something else out there that will do a better job at this than I did.

So, today, my “chain link” was partially taking that script and setting it up to run from the GIT pre-commit script, and partially writing this blog post.

Getting it set up to run as a pre-commit script just involved making sure it returns non-zero whenever there is a test error (or if no tests were run, which happens when make hasn’t been run yet).

The pre-commit script itself (placed in .git/hooks/pre-commit and set executable) is pretty simple:

    #!/bin/sh
    ./tests.sh
    if [ $? != 0 ]
    then
            echo "===================================="
            echo " Commit stopped due to test failure"
            echo "===================================="
            exit 1
    fi

Chain length: 1!

What’s next?

Next up, I’m acutally going to start on the meat of the project. Since I haven’t fully decided on what GUI library I want to use, nor what GUI testing framework I want to use, I’m going to start on the backend with code to manage user login info and queries (timeline searches, DMs, etc.).

I’ve got some great ideas (I think) on ways to enhance the way people have conversations over Twitter (and eventually other mediums), so you can be sure that there will be more posts about this in the future.

Walking Journal: 9 miles, thunderstorm, etc.

Thu, 27 Aug 2009 00:08:45 +0000

I walked at least 4 miles today. I’m not sure if I got too far over that, though, because a thunderstorm came through and killed the power before I could look at the exact amount on the treadmill. The last time I looked it was 4, so I’ll count it as that.

Thunderstorm

I was excited when I first saw the clouds rolling in, because we haven’t gotten a good rain for months now, and our lawn (as I mentioned in my last entry) is getting pretty brown.

However, when lightning started striking across the street from me, I started to get a little worried. That, and the fact that my wall-mounted monitor was swaying back and forth. Fun fact: speakers make a nice crackly noise when lighting strikes close by.

I don’t think I’d seen lightning strike before. It was quite a sight to see. A bright flash, then a sort of green glow and a halo of sparks that drifted slowly away from the strike point. And it happened in the same place, three times in a row, a few minutes in between. “Never strikes the same place twice” my ass!

After the storm had passed, we went outside to see how bad the damage was. Our South and street facing section of fence had been blown over into our yard, all of the fence posts simply snapped off. It takes a pretty strong wind to break a healthy 4x4, I think. We also lost the corrugated plastic roofing over half our back patio, and worst of all, the planter box with my ginger plants in it got blown over! Three out of four of the plants seem to be okay, but one of them got snapped off at the base of the stalk. We also found some roofing shingles in the back yard, so we’ll probably need to take a look at the roof when it’s light outside.

We were lucky compared to some neighbors. One guy down the street got a huge tree (somewhere around 3 feet in diameter) through the roof of his station wagon, and partway through his PT Cruiser (it hit the station wagon first, so that took the brunt of the damage). He seemed in relatively good spirits despite the damage, telling us that he was going to convert the station wagon into some sort of el Camino-type thing by cutting the damaged back half of the roof off. Perhaps all the beer he and his friend were drinking was helping him to stay in a good mood about it.

500 languages slowdown

I’ve been very busy with work and personal projects recently, and so I haven’t had much time for the 500 programming language project. I started learning about Nu, a lispy, interpreted, object-oriented language built in objective-c. I got the interpreter compiled and working on my 64-bit Ubuntu machine, which took more work than I would have liked due to the fact that most of the development of Nu takes place on Macs. Anyway, there’s a webserver for Nu, called Nunja and a Nu markdown processor, so I was thinking I’d write a simple blog engine as my Nu program. Nu is looking like a really interesting programming language so far, so it might be one I come back and spend some more time on.

But as I was saying, I haven’t had as much free time lately, so the posts have slowed down. Don’t let that fool you, though. I haven’t given up on the challenge, I’ve just accepted that it might be a while before I can be pumping out 5 languages a week. And it might, in fact, take me more than the 2 years I was originally thinking (dreaming) that it would take.

Walking Journal: 5 Miles

Wed, 26 Aug 2009 01:48:21 +0000

I’m starting a walking journal, to keep track of how far I walk each day, and to give me something to post about more frequently. Despite the fact that most of my posts on here are Probably about Programming, this is still, in fact, a personal blog, so I think posting personal things on here pretty much makes sense to me.

I’ll also use the walking journal as an actual journal, to talk about things other than walking. I can justify this by noting that I will, most likely be writing a lot of the journal while walking, so the name still works. I wrote most of this one while walking, so it works!

Walking journal

I’ve walked 5 miles since deciding to start this morning, so that’s a good start, I suppose.

Perhaps I’ll do a ~~100~~200 miles to a chumby-style thing with this. Though I have an advantage with my walking desk, because I can walk and be working at the same time. If I walked during my entire workday, I’d be able to get 16 or so miles a day without a problem, and I’d have 100 miles in no time :), so maybe I’ll make my goal about losing weight instead of a specific distance. 20 pounds to a Pandora?

I’ve redoubled my efforts at weight loss, and I’ve started both walking daily and tracking my weight again.

You can join in on the fun and track my progress on my Physics Diet profile

It looks like I’ve been slowly on an upward gain, but it’s just because I weighed myself before dinner, rather than before breakfast as I always did before, and it filled in the blanks since February, since I haven’t weighed myself since then. I’ve actually been holding pretty steady in weight, I think, so it’ll be good to break through this plateau and get my weight lower.

School’s started again in Round Rock

School is back in session. I guess no more sleeping in since the children gather outside our bedroom window in the morning to wait for the bus.

On the plus side, I can once again go out on my front lawn in a bathrobe and yell at those “damn kids” to “get off my lawn!”

I could have done that during the summer, but I would have looked a little silly when all that was out there was dead grass.

Teeth are expensive

I had a 9am (super early for me) dentist appointment today to get an impression for a crown taken. Good god these teeth are costing me a lot of money.

I’ve used up all my COBRA dental insurance from my last job, and from what I hear it’s nearly impossible to get private dental insurance, so it’s going to all be out-of-pocket from now on.

Since with my current job I’m technically a “private contractor,” because they have no offices in the US, they are just paying me what would cover insurance (though it might not cover personal insurance after my COBRA is over).

Perhaps the way to go is really personal insurance in the sense that I will put away that same money every month in case of medical emergency.

Or I could just have all my teeth removed and switch to an all-liquid diet. I’m sure Angie would love having a toothless 25-year-old husband. For sure.

Live List of the Most Popular Twitter Clients

Fri, 21 Aug 2009 09:36:06 +0000

I just put up a live list of the most popular Twitter clients. The contents of that page are updated every 60 seconds (the length of time twitter caches their public timeline).

For some reason I woke up at 7 this morning, unable to get back to sleep, and I was randomly wondering how many Twitter clients were out there, and which were the most popular. So I decided to find out.

After a bit of hacking around, I came up with the following Python script:

    from urllib import urlopen
    from contextlib import closing
    import pickle
    import json
    
    try:
        clientlist = pickle.load(open('clientlist.pickle'))
    except:
        clientlist = {}
    
    with closing(urlopen('http://twitter.com/statuses/public_timeline.json')) as f:
        json_str = f.read()
    
    tweets = json.loads(json_str)
    
    for tweet in tweets:
        source = tweet['source']
        clientlist[source] = clientlist.get(source, 0) + 1
    
    with open('clientlist.pickle', 'w') as f:
        pickle.dump(clientlist, f)
    
    total = 0
    for count in clientlist.itervalues():
        total += count
    
    with open('clientlist.html', 'w') as f:
        f.write('<html><head><title>Twitter Client list</title></head><body>')
        f.write(''.join(['<h1>Twitter Client Popularity</h1>',
                         '<div style="float: left; margin-right: 20px;">Out of <em>', str(total), 
                         '</em> Twitter messages, the following were the clients used.']))
        f.write('<table><thead><tr><th>Client</th><th>Tweet Count</th><th>% of total</th></thead><tbody>')
    
        for (link, count) in sorted(clientlist.iteritems(), key=lambda item: item[1], reverse=True):
            f.write(''.join(['<tr><td>', link, '</td><td>', str(count), '</td><td>', 
                             str(round(100.0 * count / total, 2)), '</td>']))
        
        f.write('</tbody></table></div>')
    
        f.write('</body></html>')

The script writes out a pickle file with the list of counts for each client, so multiple runs will generate a cumulative result (don’t run it more than once every 60 seconds, or you will add the same results in more than once).

It then writes out an .html file with a nice sorted list of the most common Twitter clients (well, all the twitter clients it’s seen, sorted by most common first).

I’ve set up a cron job on this server to update the file linked to above every minute, so as time goes on the list will become a more and more accurate representation of what people are using to tweet.

A brainfuck synthesizer

Thu, 06 Aug 2009 03:47:26 +0000

For my latest in my series of 500 Programming Languages, I decided to write a (simple) synthesizer in brainfuck.

Introduction to brainfuck

brainfuck is an esoteric programming language based on the idea of making a language with the smallest possible compiler. Indeed, my Python brainfuck compiler is only 30 lines of Python code, and I’m sure there are some optimizations I could have done to make it shorter if that was my goal with the whole thing.

The only data structure you get is a single array (if it were infinite you’d have a good representation of a Turing machine), and all you can do is move around this array with a pointer, increment and decrement values, input and output values, and loop.

The entire language consists of 8 commands:

> move the pointer forward one cell
< move the pointer back one cell
+ increment the current cell
- decrement the current cell
. output the byte in the current cell
, input a byte into the current cell
[ move to the matching ] if the current cell is zero
] loop back to the matching [ if the current cell is non-zero

Anything other characters in a program are ignored, and thus comments can be inserted anywhere into the program. Just be careful not to type proper English sentences with commas and periods, or you might get some funny bugs until you realize what’s happening.

That’s really all there is to the language. There are a couple of areas of behavior that aren’t standardized between interpreters, relating to the size of the array, the cell size, and handling end-of-file when inputing. Those are covered in more detail on the brainfuck Wikipedia page.

So, since this is such a simple language (to comprehend, not to write in), and I already provided a working compiler in my previous post, I’m going to do this post a little differently, and just cover the process I went through in writing my first non-trivial brainfuck program.

The idea

I tried to come up with an idea for a program you don’t normally see implemented in brainfuck, and I’ve never seen anything done with brainfuck and audio, so I decided to write a simple (non-interactive) synthesizer.

My first brainfuck program

To start out with, I wrote a program to just generate one second of simple square wave, at 4kHz (the max for 8kHz sample-rate audio).

With 8000Hz audio, there are 8000 bytes per second, so if the wavelength is two bytes (one byte high, one byte low, makes a complete single wave), that makes the frequency ⁸⁰⁰⁰⁄₂, or 4000kHz. If I doubled the wavelength, I’d get half the frequency, or 2000Hz.

    set counter to four thousand
    > ++++ four
    [ > +++++ +++++ times ten
      [ > +++++ +++++ times ten
        [ > +++++ +++++ times ten
          [ <<<< + >>>> - ]
          < -
        ]
        < -
      ]
      < -
    ]
    
    keep a zero value and generate a 255 value
    >> +++++ five
    [ > +++++ times 5
      [ > +++++ +++++ times ten
        [ <<< + >>> - ]
        < -
      ]
      < -
    ]
    < +++++ plus five (255 total)
    
    <<
    [
      >> . output 255
      < .  output 0
      <
      - decrement counter
    ]

This demonstrates how even generating a large number in brainfuck is quite a chore. I had to use four nested loops and four different cells to calculate 4*10*10*10. Still, it’s better than having 4000 plusses at the beginning of my program.

The way loops are done in brainfuck reminds me of doing loops in assembly language. In fact, brainfuck in general reminds me of assembly language, but without all those convenient opcodes you’re used to. :)

What’s your frequency, brainfuck?

Next, I wanted to generate a lower frequency, working my way toward taking user input to determine frequency.

I picked the A below middle C, which has a nice, even frequency of 220Hz. When you divide 8000 by 220, you come up with a wavelength of approximately 36. Half low and half high makes that 18 bytes per half, so I needed to update the previous program to output 18 bytes of each value instead of just one byte per value.

    222 waves of 36 bytes each equals 8000 samples for 1 second of audio
    > +++++ +++++ +++++ +++++ ++  22
    [ > +++++ +++++ times ten
      [ << + >> - ]
      < -
    ]
    ++ plus 2 more
    
    >> +++++ five
    [ > +++++ times 5
      [ > +++++ +++++ times ten
        [ <<< + >>> - ]
        < -
      ]
      < -
    ]
    < +++++ plus five (255 total)
    
    <<
    [
      >>>
      +++++ +++++ +++++ +++ eighteen up and down = 220Hz
      [
        < . output 255 byte
        > - subtract from counter
      ]
      +++++ +++++ +++++ +++ eighteen up and down = 220Hz
      [
        << . output 0 byte
        >> - subtract from counter
      ]
      <<<
      -
    ]

This version adds two extra loops and an extra cell to generate eighteen 255s and eighteen zeroes for each iteration of the loop.

Like MIDI, but crappier

So, the next and final step was to allow input of notes to play, and the lengths to play each of those notes.

I found a helpful reference on the frequencies of musical notes.

Due to the fact that brainfuck only allows you to read a single byte at a time, and because it made the program simpler over all, I decided to have the two values input for each note represent the length, in waves, and the length of each half-wave. This allowed me to use the basic structure of the previous program, and to support a wider range of frequencies without having to handle multiple-byte input for notes.

    generate the 255 byte for output
    >>> +++++ five
    [ > +++++ times 5
      [ > +++++ +++++ times ten
        [ <<< + >>> - ]
        < -
      ]
      < -
    ]
    < +++++ plus five (255 total)
    <<
    
    , read in the length of the first note (in waves)
    > , read in the length of each half wave
    [
      <
      [
        >
        [->>+>+>+<<<<] copy the value to two cells for use in the following loops plus an extra copy
        >>>>[-<<<<+>>>>] copy the value back to the original location
        <<
        [
          < . output 255 byte
          > - subtract from counter
        ]
        > goto next counter
        [
          < . output 0 byte (zeroed by the last loop)
          > - subtract from counter
        ]
        <<<<
        -
      ]
      , read in the length of the next note (in waves)
      > , read in the length of each half wave
    ]

Since the half-wave length is input from the user, I can’t simply re-generate the value each time through the main loop, so I had to make extra copies of the value, and then re-copy the value back to its original input location, since it’s zeroed out when it’s copied to the other location.

Like I said, it’s harder than assembly language.

Now all you have to do is fire up your favorite hex editor and create a binary file with a list of lengths and notes (for example mary.notes), and save the output from the program into a file (for example, mary.raw), and you will have your very own brainfuck-generated music!

In an 8-bit unsigned 8kHz mono raw PCM file. Linux users can use aplay to play this file. It just so happens the default format is the same as the output of this file. This also means you can pipe the output of this program directly into aplay, as well.

All you need now is some sort of front-end which will interactively take keyboard input and translate it into notes, and you could use this for live performances. (note: you probably don’t want to use this for live performances)

Learning more about brainfuck

I learned everything I know about brainfuck from the brainfuck Wikipedia page, and so can you!

Conclusion

This is probably not a language you want to use, like, ever.

Unless you’re a huge nerd, like myself.

Then you might want to, just for the fun of it.

If it doesn’t sound like fun to you, then you can safely say you’re less of a nerd than me.

500 Programming Languages: Python

Sat, 01 Aug 2009 12:53:46 +0000

(image source)

Python is one of my favorite programming languages. It’s almost always the first one that I reach for when I have a programming task I’d like to try out, and often enough, it’s the final language of that task, too.

Introduction to Python

On the official Python website, Python is described as “a dynamic object-oriented programming languages that can be used for many kinds of software development.”

They also claim that “Many Python programmers report substantial productivity gains and feel the language encourages the development of higher quality, more maintainable code.”

I am inclined to agree.

Though Python is a true “everything is an object” OO language, you can do more than just Object-Oriented programming with it. You can do plain-ol’ procedural programming, functional programming, Object-Oriented programming, and probably some other types of programming if you wanted.

One of the nicest things about Python is the “batteries included” approach, which means that Python comes with a ton of modules that do a large amount of what you want to do, right out of the box (or tarball, or installer…I don’t know if you can actually get Python in a box). Does your app need to write a cgi app? Or even better, a wsgi app? Web client? Web server??

Yep, it has all those, and many, many more.

There are many, more thorough introductions to Python out there, so I won’t attempt to cover the language in too much more depth, but I will show you a couple of things that really capture the spirit of Python:

    Python 2.6.2 (release26-maint, Apr 19 2009, 01:58:18) 
    [GCC 4.3.3] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>> from __future__ import braces
      File "<stdin>", line 1
    SyntaxError: not a chance
    >>> import this
    The Zen of Python, by Tim Peters
    
    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren't special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess.
    There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you're Dutch.
    Now is better than never.
    Although never is often better than *right* now.
    If the implementation is hard to explain, it's a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea -- let's do more of those!
    >>> import __hello__
    Hello world...
    >>>

My First Python Program

This is far from my first program in Python. I first discovered Python when I was in High School, so possibly as early as 1999-2000. I had discovered Blender, a free 3D editing application, and it had Python embedded within it, for use in creating extensions and scripting games for the built-in game engine. Back then, I still thought I was going to be a video game developer, so I made some effort to learn Python so I could write games in Blender.

Anyway, enough history. :)

For this program, I implemented a Brainfuck-to-Python compiler. I won’t go into Brainfuck right now because I will be doing a post on it next.

This program is nowhere near demonstrating all of, or even a large number of, Python’s features, but it does demonstrate how easy it is to write a quick-and-easy program.

I threw this compiler together in less than 5 minutes, and it functioned properly on my first try (the Brainfuck hello world from Wikipedia).

The only addition I had to make later was handling the case of end-of-file on the input.

    def compile(program):
        indent = 4
        code = [
            'def compiled(input=None, output=None):',
            '    import sys',
            '    if not input: input = sys.stdin',
            '    if not output: output = sys.stdout',
            '    i = 0',
            '    a = [0]*30000'
            ]
        commands = {
            '>': 'i += 1',
            '<': 'i -= 1',
            '+': 'a[i] += 1',
            '-': 'a[i] -= 1',
            '.': 'output.write(chr(a[i]))',
            ',': 'a[i] = ord(input.read(1) or "\0")',
            '[': 'while a[i]:',
            ']': ''
            }
        for command in program:
            line = commands.get(command, None)
            if line: code.append((' ' * indent) + line)
    
            if command == '[':   indent += 4
            elif command == ']': indent -= 4
        exec '\n'.join(code)
        return compiled

This function takes a string containing BF code as its one argument and returns a function which will run that code when called.

The function returned will have two optional arguments, input and output, which are expected to be file-like objects (at least implementing read and write, respectively), which allows for passing in specific input and/or handling the output from within a python program.

It’s kind of a dirty way to do it, building Python source, an then running it with exec, but it gets the job done. I could also save the function to a compiled .pyc file, so you could later import it directly, but that would require a bit more code and ruin the simplicity of it all. I could also have generated input for my Python assembler, and used that to generate a compiled .pyc file, but like I said, I was going for simplicity here, and encouraging people to learn Python, not necessarily Python bytecodes.

You can download the Brainfuck-to-Python Compiler if you’d like. You can download the Brainfuck-to-Python Compiler if you’d like.

continue on to learn more about Python

Anatomy of a Python program

Modules

Python is organized in modules and (optionally) packages. A module is simply a file which contains some amount of Python code. A package is simply a directory which contains some number of modules.

You can import modules with the import statement, which runs the code in the module, and then imports any objects the module defines into the current context (generally under some namespace, see the Python Modules documentation for more details on the import statement).)

The code in a module can be at the module-level, outside of any functions, or it can be contained in functions and classes. Code at the module level is run immediately when the module is imported.

For short scripts, it’s usually fine to write code at the module level. For more complex modules, it’s common practice to put all the code into functions, and then conditionally invoke that function if the module is run directly.

For example, to extend my BF compiler above to be invoked directly from the commandline, I added the following code to the end of the bf module:

    def cmd_line():
        import sys
        if len(sys.argv) < 2:
            print('usage: %s bf_file\n' % sys.argv[0])
        else:
            try:
                with file(sys.argv[1]) as f:
                    bf_fn = compile(f.read())
            except IOError, msg:
                print("couldn't read file %s: %s\n" % (sys.argv[1], msg))
    
            bf_fn()
    
    if __name__ == '__main__': cmd_line()

The cmd_line function is just a regular function. The real magic happens on the last line there. At the module level, name will be set to “main” if the current module is the one which was run directly.

If a module is imported from any other module, name is set to the name of the module.

Python Shell

You can also run Python code directly, one line at a time, from the python shell. The shell comes up if you just run Python directly without specifying a module for it to run.

Python makes a great calculator, random-number picker, interactive prototyping tool, etc.

Often when I’m playing around with an idea for how to do something, I’ll just open up the Python shell and play around until I get it working how I’d like, then I will commit the code to an actual file.

Installing and Running Python

There’s a nice guide to installing and running Python on various systems at Python.org, so I won’t spend time repeating what they’ve got there.

Learning more about Python

A good place to start is the Python tutorial, and there’s a lot to learn from the links on the Python Documentation page.

Conclusion

Python is a great language, for both new programmers and experienced programmers who want to try a language that is probably way nicer than what they’re used to programming in, especially if what you’re used to programming in is PHP. Heck, even Terry Chay recommends Python as a learning language, and he’s known to be a strong supporter of PHP.

In conclusion, if you haven’t yet, give Python a try. You won’t regret it!

The 500 Programming Language Challenge

Mon, 27 Jul 2009 17:15:43 +0000

Are you a programmer? If so, then I have a challenge for you. I want you to become a programming linguist.

While making (somewhat slow so far) progress on my goal to program in 500 programming languages, it occurred to me that this could be a much more interesting project if I got more people involved.

I’m still aiming for my goal of writing about and in 500 different programming languages, but here’s my challenge to other programmers:

Write 500 different programs, in 500 different programming languages.

That’s it, that’s the whole challenge, well, with a couple of rules, I suppose:

The 500 programs must be written after reading this post. No fair counting them if you’ve already (somehow) written 500 programs in 500 different languages, so they have to be new.
The programs need to be semi-non-trivial. Something a little more advanced than “Hello, world.” To use one of my previous programs as an example, an implementation of the game of life is a semi-non-trivial program. Ideally the example will demonstrate some of the strengths of the language, as well.
They languages used need to be different languages. It doesn’t count if you write in 500 different dialects of Basic, for example.
Share your results with the world. Either post them on your own blog or put them on github, or whatever, just get them out there so other programmers can see and learn from them.
Deadline: there isn’t one. Since this is a fairly long-term project, and I know varying people have varying amounts of free time for such a thing, I’m not putting any sort of cap on this. I’m shooting for 3 years or less to completion, but it could just as easily be a ten-year goal, or a one-year goal for someone particularly insane/enthusiastic.
Winner: there also isn’t one. The idea is to encourage as many people as possible to do this. However, there is sure to be some recognition for the first one to accomplish the goal. I mean, seriously, how many people have written in 500 different programming languages?

So, it’s ok if you write some of them in languages you’ve written in before, but you need to write a new program, and it needs to at the very least do something more interesting than “Hello, world” or “99 Bottles of beer”

I’d love to see people take this challenge to an interesting extreme, such as writing a programming that does the same thing in 500 different languages, or writing only in esoteric programming languages.

I’ll put up a gallery and perhaps do interviews with/profiles of any developers who participate in the challenge.

Become a Programming Linguist

In my mind, there are 3 different kinds of programmers: the single-language programmer, the typical programmer, and the polyglot programmer.

The single-language programmer

This programmer is either very picky, very new to programming, or not someone who programs for a living. The latter two are acceptable, the former one really isn’t.

I would neither like to work with someone who refuses to program in anything but Haskell nor someone who refuses to program in anything but Visual Basic (though out of the two I’d pick the Haskell programmer).

If you’re new to programming, or don’t plan on doing it much, it’s acceptable to only know one language, but if you even only plan on writing Ruby On Rails or PHP web-apps for the rest of your life, you should probably at least know JavaScript and SQL as well.

The typical programmer

This programmer has learned a few programming languages, perhaps the Ruby/PHP, JS, and SQL mentioned above. This programmer knows everything they need to do their current job, and hopefully enough to do it *well.

The typical programmer isn’t too afraid to pick up a new language when they feel a need to do so. Generally this need is brought up by work demands or growing tired of the language they use primarily.

Still, this programmer tends to stay away from “weird” programming languages, be they functional, stack-based, or simply something with an odd syntax compared to what they are used to. Such languages seem like they would be too much work to learn, without any practical benefit for this programmer who already has a good list of languages that do what they need.

With this self-inflicted limitation, the typical programming is truly missing out on some profound, powerful knowledge that they could gain if they even just took a little time to understand these foreign paradigms, let alone actually program in them.

The polyglot programmer

This programmer loves programming, and more importantly, loves programming languages.

The polyglot programmer doesn’t let as trivial a thing as “not needing to” prevent them from learning a new programming language. They seek out new paradigms and techniques and revel in their ability to apply what they learn from one language to a language they already know, thus making them a better programmer.

This programmer understands that there is a reason for every programming language design decision (even if that reason is “we didn’t think about it too much”), and can’t wait to try out a new language feature they’ve as-yet not encountered.

A polyglot programmer can apply for jobs that a typical programmer can only scoff at for requiring “one of those weird programming languages” that they could never be bothered to learn, and they can more quickly learn a new language that their current job might require because they have a better understanding of programming languages in general.

A programming linguist is basically a very-well-versed polyglot programmer, one who can pick up a new language in a day if there is any good documentation for it

The goal

The goal here isn’t to learn and become an expert at all of the 500 different programming languages. The goal is to be exposed to 500 different programming languages, to glean a bit of knowledge, to open one’s mind to new ways of looking at and solving problems, and to ultimately become a better programmer.

It doesn’t matter if after this, you never touch any of the 500 languages ever again, just the act of coming to understand the language enough to write a program in it will have altered your mind enough to make a lasting impact, especially for languages which are different from the “norm” of what you are used to.

Will you accept this challenge?

If so, let me know in the comments or an email.

If not, let me know why not. I'd love to hear from you either way.

Probably Programming

Well, this is embarrassing.

sated: a Programmer's Editor for you

sated is for you, programmer

Why this is viable

How I’m planning on making money

How I got here

What’s next

Comic-Fu

⚃ Rolling Dice with JS and Unicode ⚂

A save your place bookmarklet

Fun with bookmarklets and CSS3 transforms

A Simple Lisp Parser in Python

IE7 Requires type="submit" for elements

Walking Journal: 45 miles, starting a Twitter client chain

The Twitter Client Chain

Tests and pre-commit hooks

What’s next?

Walking Journal: 9 miles, thunderstorm, etc.

Thunderstorm

500 languages slowdown

Walking Journal: 5 Miles

Walking journal

School’s started again in Round Rock

Teeth are expensive

Live List of the Most Popular Twitter Clients

A brainfuck synthesizer

Introduction to brainfuck

The idea

My first brainfuck program

What’s your frequency, brainfuck?

Like MIDI, but crappier

Learning more about brainfuck

Conclusion

500 Programming Languages: Python

Introduction to Python

My First Python Program

Anatomy of a Python program

Modules

Python Shell

Installing and Running Python

Learning more about Python

Conclusion

The 500 Programming Language Challenge

Write 500 different programs, in 500 different programming languages.

Become a Programming Linguist

The single-language programmer

The typical programmer

The polyglot programmer

The goal

IE7 Requires type="submit" for