Programming

The earliest memory I have of ‘programming’ is in the early/mid 90s when my father brought home a computer from work. We could play games on it … so of course I took the spreadsheet program he used (LOTUS 123, did I date myself with that?) and tried to modify it to print out a helpful message for him. It … halfway worked? At least I could undo it so he could get back to work…

After that, I picked up programming for real in QBASIC (I still have a few of those programs lying around), got my own (junky) Linux desktop from my cousin, tried to learn VBasic (without a Windows machine), and eventually made it to high school… In college, I studied computer science and mathematics, mostly programming in Java/.NET, although with a bit of everything in the mix. A few of my oldest programming posts on this blog are from that time.

After that, on to grad school! Originally, I was going to study computational linguistics, but that fell through. Then programming languages (the school’s specialty). And finally I ended up studying censorship and computer security… before taking a hard turn into the private sector to follow my PhD advisor.

Since then, I’ve worked in the computer security space at a couple of different companies. Some don’t exist any more, some you’ve probably heard of. I still program for fun too, and not just in security.

But really, I still have a habit of doing a little bit of everything. Whatever seems interesting at the time!

Recent posts (Page 64 of 74)

Expanding L-systems

2012-09-15 in Programming

An L-system is essentially a set of rewriting rules that turns a simple set of rules into a complex pattern. They’re generally used for generating self-similar fractals, including plant life, but I’ve also seen them used in programming languages research where they can generate valid programs given the grammar of a language. They’re also rather similar to turtle graphics in that many of the sample graphics that I’ve generated in the past are based directly off the L-systems page on Wikipedia. So this time I’ve decided to work on a relatively simple macro that can be used to expand simple L-systems.

read more...

Generating Voronoi diagrams

Generating Voronoi diagrams

2012-09-09 in Programming

I was playing with image library and started to think about more ways that I could generate images. One idea that came to mind was to generate a bunch of colored points on the image and then color every other pixel based on which seed point was closest. Turns out, that’s exactly what a Voronoi diagramis… The Wikipedia article at least says that Voronoi diagrams can be traced back at least to Descartesin 1644, so I guess at least I’m in good company. 😄

read more...

Backing up Google Reader / Calendar

2012-09-05 in Programming

Similar to my previous post about backing up Gmail, this time I want to back up my here, from there it should be easy enough to derive the one for Google Calendar.

First, we have the same setup as last time. Yes, I’m still storing the passwords in plaintext. Perhaps I’ll write up a way to avoid this in the future.

#!/usr/bin/env python

import urllib, urllib2

username = '#####'
password = '#####'

For the next step, I’m going to fetch Google’s login page using urllib. Note the service we’re sending in the POST parameters. This tells Google what we want to access (Google Reader in this case).

read more...

Backing up Gmail

2012-09-03 in Programming

A little while ago, I decided to finally get around to backing up everything. I’m pulling all of my files from both my website and the servers on campus to my desktop at home, backing my desktop up to an external hard drive, and pushing those backups to an offsite location.

The former two steps are using here.

First, some basic setup. Of course, I’ve blanked out my own username and password. This definitely isn’t the best way to authenticate (storing the password in plain text? :(), but it works out well enough.

read more...

Random Access Lists

2012-08-30 in Programming

This time around, Programming Praxis here (make sure you download pmatch as well).

First, we need to provide tree functions that are designed to work on complete binary trees, taking the size as an additional parameters.

; lookup an item in a balanced binary tree
(define (tree-lookup size tr i)
  (pmatch (list size tr i)
    [(,size (Leaf ,x) 0)
     x]
    [(,size (Leaf ,x) ,i)
     (error 'tree-lookup "subscript-error")]
    [(,size (Node ,x ,t1 ,t2) 0)
     x]
    [(,size (Node ,x ,t1 ,t2) ,i)
     (let ([size^ (div size 2)])
       (if (<= i size^)
           (tree-lookup size^ t1 (- i 1))
           (tree-lookup size^ t2 (- i 1 size^))))]))

; update a balanced binary tree with a new element
(define (tree-update size tr i y)
  (pmatch (list size tr i y)
    [(,size (Leaf ,x) 0 ,y) 
     `(Leaf ,y)]
    [(,size (Leaf ,x) ,i ,y) 
     (error 'tree-update "subscript error")]
    [(,size (Node ,x ,t1 ,t2) 0 ,y)
     `(Node ,y ,t1 ,t2)]
    [(,size (Node ,x ,t1 ,t2) ,i ,y)
     (let ([size^ (div size 2)])
       (if (<= i size^)
           `(Node ,x ,(tree-update size^ t1 (- i 1) y) ,t2)
           `(Node ,x ,t1 ,(tree-update size^ t2 (- i 1 size^) y))))]))

With that, we have everything we need to represent the lists. A random access list will be defined as follows:

read more...

All posts