I can recall being with my family in southern ohio on a pontoon boat, on a lake in the woods. There was a strict “no technology” policy enforced ruthlessly by my parents. Of course I hated it, and the next best thing I was allowed to do was bring my programming books with me.

“Teach yourself java in 21 days” was an incredibly well-written book. I read this book so much and so often that the flimsy paper cover lost its plastic and ended its life with a barely recognizable cover in the ACM office at UIUC. I believe it’s still there.

But what’s remarkable to me is that I didn’t have a computer when I learned the guts of my java knowledge. This was probably 8th or 9th grade. I’d played with VB for a year or two, and before that made my own little html/css/javascript web pages on angel fire in middle school. It’s fascinating to me to look back and see how my programming skills and knowledge accumulated. It was, almost 100%, for fun. All of it. I’ve had several discussions about “why” people want to code. And holy hell, are people different. Some people want jobs. Some people chose CS when they got to college because it looked neat. Some people learned from classes, others from digging into open source projects. Some people attended lectures, others read books. Some people loved the idea of building something functional out of nothing. Others just want to make some money. Some want to be famous hackers, others are content bit twiddling in their basements.

I remember fuzzy things about my Java learning experience. I first read an antiquated Java 1.1 book that probably cost $3 on the bargain shelf at border’s, and then finally acquired the 21-days java 2 book. I remember the first time I understood what GridBagLayout meant, and I absolutely remember the first time the “interface” idea caught on, with respect to java’s class ideology. Class inheritance? Lightbulb moment. How event handlers worked? Done.

All of these lightbulb moments occurred many miles away from the nearest computer. That fact hasn’t detracted from my ability to acquire new programming skills and understand different ways of thinking about code. I’m certainly not saying it’s helped, but I suspect it has.

It’s been so long since I “learned” how to program that these memories are starting to surface.

Take catharsis, for example. It is a very real phenomenon. Crying literally seems to “release” emotions. Sadness, stress, and the like are literally made up, on the inside, of hormones in our bodies. What causes them? Our consciousness causes them.

When you get angry, it’s because of your mind. You have comprehended something that has triggered in your mind a feeling of anger, which underneath is just a combination of chemicals coursing through your blood.

Emotions are quite literally the link between consciousness and the physical underpinnings by which such consciousness arises.

Why is Apple the only company that makes technology that doesn’t look like it was crafted by robots?  There are several common answers.

1) They control the entire supply chain and are vertically integrated.  This is a fact.  However, I don’t think this answers the right question.  For example, there was a long period (basically when Jobs was absent) when Apple’s products were nowhere near as awesome as they were before and after.  Being vertically integrated allows Apple to exercise a seemingly unmatchable amount of control over their products and keep their costs low.  It doesn’t mean they automatically make better products simply because they’re cheaper.  It just means they have more control and keep costs down.

There’s a quote from Alan Kay that goes like this: “People who are really serious about software should make their own hardware.”  Can you name a single other company that does this?

2) The best designers work at Apple.  I hear this a lot — and I think it’s obvious that it’s not true.  Two things are happening here: Apple has good designers and bad designers, and we see the cream of the crop in Apple products; and lots of good designers never see their ideas pushed into production.  Additionally, a good design isn’t equivalent with a good product.  And what does “design” mean?  It’s not granular enough.  The Newton looked good but sucked.  Why did it suck?  Because while it looked good, it lacked that critical balance of design on the outside and the inside.  The user experience wasn’t there.

3) It’s Steve Jobs.  While the correlation between Apple’s success and Steve Jobs’ presence at the company is undeniable, I am still not convinced Apple will start making shitty products when Steve is gone.  Jobs has spent the past decade and a half working with the entire company to build these great products.  It’s not just him; he’s just the public face.

So what is that balance Apple strikes in order to make beautiful technology?  They took multitasking away from us.  Multitasking.  If you had asked someone in 2001 if it made sense to disable MULTITASKING, they would’ve laughed in your face and called you a charlatan for questioning something so basic to everyday computing.  Why did Apple do it?

They did it by changing the question.  Technology doesn’t exist solely for humans to choose between the best solutions.  That’s what the market is for.  Technology exists to make our lives easier, to take away those pain points.  Once those pain points are identified, technology can make our lives BETTER.  It can connect us with people, but again, those connections aren’t about choice; they’re about the best experience and how to facilitate human connections.

This is what I want to do.  I want to create technology that enhances our lives and makes a difference.  Apple products inspire me because they show that it’s possible to show people something they haven’t seen and didn’t even know they wanted.  I remember trying desperately to convince my parents to buy android devices when they decided to throw away the old flip phones.  After a year and a half, my mother had countless problems.  And she’s a smart woman.  Her email would get screwed up, she’d have to reset her account, constantly couldn’t figure out how to upload a photo somewhere or listen to music.  She wasn’t forgetful; I completely understand her problems here.  It just wasn’t as easy to use as it could be.  At one point, I handed her my iPhone and asked her to check her mail.  She did it with ease.  I then asked her to find me the quickest route to the nearest grocery store (we were in an unfamiliar area) and it worked without a hitch.  She asked no questions, had zero problems, and everything worked.  It was like magic.  A week later she bought an iPhone.

People shouldn’t need to understand how technology works in order to use it.  At all.  I think the biggest reason not many people make sexy technology is because most people making the tech don’t know what’s sexy.  They don’t know how.  Jobs, Ive, and the countless others at Apple know how to do this.

I often get raised eyebrows when I confess my apparent Apple fanboy-ism.  The reason I love Apple products is because I don’t need to understand how they work in order to use them.  Isn’t that the goal of technology?  Apple got it right — choice is only a secondary priority.  The first priority for technology is to make it magical.

In general, the language seems — immature.  Or rather, the community, tools, libraries, and documentation surrounding clojure are not very old; versions of tools and libraries tend to clash and it’s pretty difficult to find actual code examples.  The web is, of course, full of documentation, but it tends to be spec-based.  Abstract.

Example: I’m currently stuck in a spot where I’ve defined a POST handler.  When I try to pass POST data to the handler via curl or in a browser, I get a 404.  A 404.  Not a 500.  No exception are thrown.  For some reason, the library I’m using (Compojure and Ring) can’t “find” this handler.  Which obviously makes no sense.  Asking questions on Stack Overflow takes days at best; what the hell am I supposed to search google for?  The handler responds correctly to GET requests, but not POSTs.

I also ran into an issue with clojure-redis.  I want to store the game state as a JSON object mapped to a unique game identifier (like a URL shortener or etherpad) but when I tried, in my ubuntu VM, to redis/set a key and value, it actually set the LENGTH of the string instead of the string itself.   Inexplicable.  Running the SAME code on my Snow Leopard host OS gave the expected, correct results.  I can only conclude it was a version incompatibility.  There are ZERO instances of this happening on the web.

Examples aside, my point is that I really do enjoy programming in Clojure.  But the documentation and code samples are sparse at best.  Most people who use it tend to have lots of lisp experience already, which leaves me in the dust.  So that sucks.

Anyway, it’s been full of headaches so far, but the advantages of thinking in a functional language far outweigh (so far) the headaches.

Onward!

Shift to programming nowadays.  Everything we write is based upon certain rules.  We assume, for example, that defining a function with certain parameters is compiled in such a way that it will always be called with those parameters — this is a necessary precondition that our compilers enforce and make life simple and easy.  But our solutions with code are often very buggy and inelegant (some of us more than others!).  They don’t always scale well — scaling usually requires many changes, additions, subtractions, and modifications to whatever our infrastructure is.

In nature, evolution serves this purpose.  The process of natural selection is the agent of necessary change — if you don’t work, goodbye.  Nature is a process, things are consumed and produced.  Always.  Programming doesn’t really work this way, at least not at a fundamental level.  If an organism runs out of food, it dies.  If our programs and functions aren’t called, they always sit around waiting for input or to be invoked.

This might be complete nonsense (in fact, it probably is).  But I wonder what a software system would look like if it was somehow to inherit these attributes of nature?  If a function is never used, perhaps it is discarded.  But where do we get the function or module that will replace it?  In nature, organisms reproduce.  Code doesn’t really do that, at least not in the same way.  Genetic algorithms are sort of analogous, but only insofar as they behave like nature.  Code itself isn’t actually modified, just the state of the data.  The fitness function is always the same, the production process is always the same.  Self-modifying code isn’t robust enough, either, for this task.  It mainly seems to be used to simplify how things work — not to evolve or consume/produce.

So what would programs consume?  What would they produce?  At a high level, data is consumed and analysis is produced in the form of (hopefully) value.  But again, if information flow stops, programs just wait.  This would definitely be a disadvantage, so there would have to be a corresponding advantage.  What’s the tradeoff?  Is there a way to make programs more efficient, faster, or more reliable if they don’t always assume they’ll be provided with X amount of data?  What could they sacrifice?

This has been extremely stream-of-thought.  Got to come back and think more about it later.

This is a surprisingly simple table to memorize, and quite fast.  I was able to reproduce this from memory after only a minute or so.  A-E seem to map to 1-5 very easily, and after that, the number 6 starts with an S, the letter H has common symmetry with the letter 8, 9 starts with an N, and 0 is the same as O.  Only 7 – G seems to be arbitrary — but since it’s the only one, it’s easy to remember.

Using this system, you can convert numbers into mnemonics.  The example given on wikipedia is that Bill Gates and Chuck Norris is equivalent to 27 39.  You can fudge this a bit into a story along the lines of: Bill Gates was round-house kicking Santa Claus when he first landed on the moon = Bill Gates, Chuck Norris, Santa Claus, and Neil Armstrong = 27396391.

Steganography is the practice of hiding information in plain sight.  Examples include everything from using invisible ink to utilizing the unused bits of low-resolution images to store data.  I bet you could use the mnemonic dominic system to hide information, albeit in a very long-winded, tedious way.

This probably isn’t original.  I’m sure someone has thought of this before, but it’s interesting to think about anyway.  The problem is the fuzziness of the process — to build a system for encoding and decoding, we need a way to define how “distant” the chosen words can be from their association.  For example, round house kicking means chuck norris.  Does texas ranger also mean Chuck Norris?  How can we know that without ambiguity?

Also, what do the numbers mean?  They could represent anything, for example ASCII or Unicode characters.  There is also the question of how these encodings would be formatted — presumably these aren’t complicated questions.  The problem seems to be that the efficiency of the system depends on the type of data being “encrypted”.  So, if I wanted to use a newspaper article to store textual data, many words would be required to express only a few letters (if I was using something like ASCII).  So this definitely isn’t a system that compresses.  It explodes.

Maybe that’s okay if we care more about security rather than efficiency.  This system is sort of an analog to the code talkers of world war 2.  Neato.

Again, this probably has no practical purpose.  It’s fun to think about, though.

Unfortunately, my current project involves some manipulation of photos.  And, since I have an iPhone 4 (fancy!) the photos are pretty high resolution.  I’ve also discovered that the iPhone SDK doesn’t have a very robust image manipulation (read: effects of any kind) library.  So I’m stuck implementing the grimy part in C++.  Yuck.

It’s been pretty educational so far.  We are what we repeatedly do, and I’m certainly not a low level coder.  Python has been my language of choice for the past several years, which means I (generally) don’t have to worry much about overflowing buffers or forgetting to deallocate memory.  Richard Feynman had some quote about seeking the highest breadth of experience, not just in science but in any pursuit.  Jumping from Python to Objective-C certainly isn’t as bad as I expected (and I still find myself loathing C++), but it’s a big enough jump to remind me not to forget about the incredible number of avenues software offers.  Hopefully my eyes will see the ever-elusive secret to good software design.  If anything, it’s more data for my neural network to “train” itself

Also, I’ve decided I want a kindle.  I’m going to use that as a good revenue goal for my new project.

One of the big lessons at Djangy was how much sense it makes to use git to move collections of files around.  Adding other machines as remotes and executing git push is conceptually easier and simpler than trying to remember hostnames and credentials and which files you care about.  You do all that setup at the beginning, when you initialize your repository, and then you can always do a git push whenever you want to move files again.  It’s fantastic.

This is obviously not the reason git was created.  It’s a version control system — these niceties are just added value.  Would it be possible to create a new tool that has all the conveniences of this paradigm without all the cruft of a version control system?

The reason this works so well is because a repository is a collection of files (and their versions).  We can safely discard the idea of versions for now, which we could accomplish by having a config file in  the root of our “repository”.  Or, more explicitly, we could define a file that merely references all the files or directories we care about.  Then, similarly, we have remotes and credentials specified in that file.

I might try to write this.  It wouldn’t care about whether or not I’m using a working copy, or if I have any uncommitted changes, or any of that.  I would just be required to add or remove files from my repository and push them.

Hmmm.  Does it make sense to “pull” in a system like this?  It might.  But it wouldn’t do merges, it would just pick the copy of the file with a later timestamp, or more simply, just overwrite everything.

This system could be built the same way git is built; in fact, it might make sense to fork the git project and build it from that.

I have no idea if this actually solves any problems or if it offers and performance advantages.  It’s definitely simpler.  Perhaps nobody would use such a system.  But it might be fun to build.

He was in his early 30s when he decided to get into the budding oil industry in Texas.  He wasn’t successful until he was at least 40.  Cullen basically spent ten years educating himself on the industry.  He worked for other people, he worked with other people, and basically failed time and time again for ten years.  Then when he finally decided to go out on his own, trust everything he’d learned, he failed some more.  He went from property to property, negotiating oil leases for pennies, taking all the risk himself.  He promised profit-sharing for the landowners and (at least so far) was honest.  His first success is just fun to read: he gathered his family around, and while they were all dressed in their nice Sunday clothes, he started his drill.  Just as he predicted, he struck oil and the black goop erupted into the air while he danced underneath it and his family cheered.

After a few more successes, he was approached by his initial investor, Jim West.  West wanted to invest $1 million in a new oil company with Cullen as the president owning 25% of the company.  After a week of silence, West asked Cullen what was taking so long for an answer.  Cullen responded with an offer of his own: that West and Cullen both put in $5000 with a 50/50 stake, and Cullen would remain in charge of everything.  West was incredulous: he obviously couldn’t figure out why Cullen would offer such a crazy deal.  Five thousand instead of one million?  Cullen’s answer: “This way, I won’t be working for you.”

West and Cullen then flipped a coin to decide whose name would come first: Cullen won, and they founded Cullen & West.  They bought two rigs of their own (still incredibly modest for the time) and set off to find more fields.  Cullen’s insight to dig deeper than other oilmen required him to innovate: he found a unique way to shatter the shale beneath most oil fields, which landed him his next wildly successful rig.  And the story continues.

The number of parallels between the early oil industry in Texas and modern Silicon Valley are piling up in surprising numbers.  Hopefully I’ll be able to write more about them in future posts.