russell holt

redoing my little site here. will be bringing lots of old stuff out of exile soon. and also cuts.com parts 2 and 3 almost ready.

In real life, I’m not a professional programmer. Not anymore. I hang with my girls, especially during the summer. This affords me some perspective, mainly the I wish I could hack on my computer more often perspective. But I was recently talking with friends about random programming topics and after all these years of not doing intense programming (often none at all for extended periods) has left me feeling cold about programming languages in general.

When you the experienced programmer are deep in your project you have an intricate mental model of your code, the libraries and apis, the file structure, the language and associated tools and even the hidden internal processes and machinations of the compiler or interpreter. Let us not forget also your project plan, requirements, milestones, web traffic, code you cut out and abandoned branches in the source repository, some article you read about a technique you want to try, examples in books, code you found on google code, etc. And for me there was always the time gap between issuing the compile command and its output - I always had abstract visual images for the process of compilation, and once in a while had the strange experience of knowing without knowing the specific error(s) I’d be told. Was I compiling it, in my head? Was I so close to the process that my subconscious picked up on errors that my conscious mind did not?

(more…)

This quote is great:

Long ago, Socrates described some second thoughts he had about the new and questionable technology called a “book”. He thought it had several weaknesses. A book could not adjust what it was saying, as a living person would, to what would be appropriate for certain listeners or specific times or places. In addition, a book could not be interactive, as in a conversation or dialogue between persons. And finally, according to Socrates, in a book the written words “seem to talk to you as if they were intelligent, but if you ask them anything about what they say, from a desire to be instructed, they go on telling you just the same thing forever.”

via Lucinda from marca from Thinking Like Einstein.

And Socrates was right. Those are weaknesses of books. Unlike other people commenting on this quote, the point here is not that good old Socrates thought books would fail, or the written word had low value. The point is that inquiry is interactive and knowledge is alive. Only after thousands of years of the book are we finally able to address these weaknesses.

I know you won’t believe me, but the highest form of Human Excellence is to question oneself and others.

Confessions of a Samurai Coder describes an experience probably every developer has had. Struck with a vision for improvements to the (currently working) system, you jump into a late-night battle of systemic, structural changes… which do not work in the end. What really happened? Was it an impure vision? Did it require a more strategic rather than heroic effort? Was it just too complicated? We can’t really tell from the post, but the imagery - the hero fighting through the jungle of code - is as familiar as the keyboard to many of us.

Some argue that a software development process is either broken or nonexistent when heroic efforts on the parts of individuals are required to complete the project, rescue it from certain death, or even make simple changes. In this view, managability is paramount - the organization is a giant machine and musn’t rely on the efforts and talents of specific individuals. While this may be appropriate for some things, the very intangible nature of software requires a heroic comprehension of the system. Software design is not like a bridge or a house - you cannot stand back and see the big picture of a software system with your own layman’s eyes. No pictures or abstract representations adequately translate software into structures we humans have evolved to comprehend and reason intuitively about.

(more…)

This is part one of a three part meditation on cuts.com and the future of video, interactive and narrative-centric media. In this part I give an overview of cuts.com and talk about where the idea came from.

You might not have heard about cuts.com - so-called “virtual editing” of commercial DVDs and, later, online video. I co founded it in 2005, but sadly it is just about done now. Here I will tell a bit of the story, why I think the ideas are important, and what can come next. If this is too boring, just skip to the big questions and more interesting ideas in part three [when I finish it].

part one: the seed

• cuts overview
• originated with digital audio
• media players become more complex as media gets more flexible

part two: what happened

• cuts.com founded, hires CEO, launch at DEMOfall 2006
• Google buys YouTube, iTunes video launches, …
• cuts switches to online video, drops DVD
• no profit

part three: what’s next

• what is “a video” ? the net changes notions of finality and single noun-ness of “a work” like film
• how to make movies in the age of the web : a return to the traditional storyteller, narrative-centric, viewer-specific experiences.

(more…)

I’m reading Everything is Miscellaneous by David Weinberger (of The Cluetrain Manifesto fame). So far it is a worthwhile read, though I’ve really just started. One of the true liberations of the digital world is that it shows us how much our old ways of organizing and categorizing things were tied to physical limitations. Weinberger writes about “three orders of order”- the first is the organization of things themselves, such as books on shelves; the second order is how The Experts have decided to categorize and label the things, such as the card catalog or the Dewey decimal system; the third is us - the web - the digital disintermediation - social networking - constant ad-hoc order and reorder routing around the experts.

“Second-order organization, it turns out, is as often as much about authority as about making things easier to find,” writes Weinberger.

We have entire industries and institutions built on the fact that the paper order severely limits how things can be organized. Museums, educational curricula, newspapers, the travel industry, and television schedules are all based on the assumption that in the second-order world, we need experts to go through information, ideas, and knowledge and put them neatly away.

But now we- the customers, the employees, anyone - can route around the second order. We can confront the miscellaneous directly in all its unfulfilled glory. We can do it ourselves and, more significantly, we can do it together, figuring out the arrangements that make sense for us now and the new arrangements that make sense a minute later.

(more…)

I subscribe the the fire escape theory of process or user interface design, which is to say that things which we rarely use are those things which should be the easiest and most intuitive of all. Things we do everyday can almost be of arbitrary complexity because we get so many opportunities to practice. We’re good at learning by doing, but when you have to flee the burning building there is no time to think or figure it out. Sure, we should all practice and be ready for that situation, but the reality is that we don’t.

When we do something over and over, process improvements are easily found. So I would say that as long as people are able to modify their processes, optimization can be done over time. In contrast, the fire escape needs far more thought put into its use ahead of time simply because it is so rarely used.

Recently I have insinuated that AI, or rather AHI (artificial human
intelligence) may be a logical impossibility for computers/software alone. Or at least without creating artificial humans by reinventing nature and/or creating life. I must be fundamentally uninterested in AI to suggest that other aspects of nature, such as life, are more interesting or at least of a greater practical value should immitate some of it in software. Is a brain, after all, not a living structure, constantly changing? Even if one could conclusively pin down fundamental algorithms and data structures of human intelligence?

I see somewhat of a language and framework myopia in the software world. The specific challenge addressed by programming languages is one of describing a solution to a problem. The built program then runs. As software complexity increases, we’re faced with less solution-describing and more structure-building and structure-changing. Nature, of course, is the ultimate builder of structure and we must follow Nature’s lead in building structures on a greater scale. In the face of Nature, our systems are at once simplistic and small scale and yet inherently brittle - an embarrasing failure on all levels. One would think that the simpler system, built by an intelligence, would be more reliable than a vastly more complex system that grows on its own. Why is logic and design failing us?

What would an attempt to create living structure in software look like? It would start as a platform, much like a glorified runtime framework or operating system. But gradually, as we get a better understanding of it, our software would begin to resemble life. The key word is alive - always on, existing in an environment it changes and is changed by - along with other entities. Instead of build-run, they would be always-on. Instead of being built piecemeal or in modules, complex structures would be grown through constant micro-scale changes over time. The concept of the environment would likely include all input/output, design goals, anything remotely relevant to the system. The idea of an individual would extend to what we now call invocations of a program, rather than just the abstract program itself; individual entities would likely contain their “program”, individually subject to change over time and separated from other entities. There would be a concept of structural memory and generational change based on experience.

Some of these things sound wild and out of control to someone who has grown up creating software with programming languages. But then again, Nature is wild and out of control. Some would say, so are our software projects, and yet we don’t get any of the benefits.

So here’s my view on AI in brief.

1. Natural systems are more robust, durable, adaptive and complex than anything humans build. Nothing we do, in fact, comes even remotely close.
2. It is on this foundation that our human intelligence rests, or appeared in the evolutionary tree.
3. Can we short-circuit that? I doubt it.

Extraordinary things exist in nature - relative to what we humans can build. Without intelligence. It is my feeling then that these features of the “natural platform” are much more important than trying to create AI. Not only would software (let’s say) which exhibited the features of natural life be more useful in practical reality than AI, it is my feeling that it is a prerequisite. The creation of complex structure through the process of growth, generational adaptivity, speciation… these are the sorts of things we need to create robust, large scale software systems that can change over time. This is the sort of platform we need before we can hope, IMHO, to create something resembling intelligence.

Unfortunately, that begins to resemble life. Am I saying we need to create life in order to achieve AI? I might be. That might be the logical problem of AI in a nutshell. At least AI of the “artificial human” variety.

The end of programming languages isn’t in sight - yet.

There was a time when I cared passionately about object-oriented programming and all of its details. My personal style in learning complex new ideas has been to implement my own system from scratch. Back in the early 90s, to figure out GUI programming I wrote my own (very basic) user interface libraries first in curses, then with Xt (or was it XLib? so long ago…), then with THINK C on the mac. To understand the web, I wrote a web server (but not a browser) and a few application servers, and seeking to understand object oriented programming culinated (climaxed?) in writing not one, but two programming languages and a host of related tools including more than a few code generaters and a dynamic layer for C++ with smart pointers and a reference counting GC. What is this problem I have? Why can’t I just learn how to use a tool instead of having to make my own?

There was a time when I bought every book I could find about OO - at least, every book that seemed to introduce new concepts or put a new and interesting spin on something. My favorite book for a while was the C++ annotated reference manual (1991) - it’s kind of like the director’s cut / extended edition of C++ complete with commentary about design decisions and deleted scenes (dropped features). I hung on Alan Kay’s words in his 1997 OOPSLA speech - did he literally mean that ever object should have a URL? When I was at OOPSLA 1998 I learned about aspects from a Xerox Parc person and instantly figured out how to add support for it in my language. In fact, I at one point or another, tried to implement just about every interesting idea in object oriented programming that I could imagine, including a few of my own unusual features. I read A Pattern Language and The Timeless Way of Building and corresponded with Nikos Salingaros, inviting him to speak at my company, and led an effort to transform our consulting “best practices” to a pattern-based approach. I waited with bated breath for Alexander’s The Nature of Order.

But then something happened. I slowly began to realize that I didn’t care so much any more. Oh, I loved software and programming. But the syntax, the brace style, competing programming idioms began to just not matter all that much anymore. There was a time when I was a real C++ bigot and prided myself in knowing every last little exotic detail. But then I gave it up and converted to Java, and then one day, I wrote my last Java code and that, too, left. That was in 2002.

Nothing has taken its place.

By that I mean instead of C++ and Java, I have no language today. I am not interested in any particular programming language. In fact, the idea of discussing language syntax and types is rather dull. No - not dull, but uninspiring. The study of programming languages no longer reveals the insights into software that it once did. I’m no breadth and depth expert in all the world’s programming languages and there is still lots to learn, but this new feature and that new concept aren’t changing any fundamental perspectives or illuminating new truths. Except perhaps for quantum computing. But I don’t have a quantum computer yet and today I code in whatever is in front of me. Be it PHP, Ruby, z/c/sh, Objective-C, plain old K&R or ansi C, JavaScript, AppleScript, perl, some XSLT, scheme, and who knows what else.

I had a brainstorm one day around 2000, I think it was, where I was reading my Turing and trying to ask big and dumb questions like what is a program, and not having any spectacular luck or even knowing what value any kind of answer to that big and dumb question would have. I was also reading my Feynman’s notes on computation, and the discussion of reversible computing was quite intriguing. I was thinking of the time dimension in programs, and whether parts of programs could usefully remember what happend to them, like whether I could inspect an ‘if’ statement and see the data it has considered in its lifetime as part of my code, and whether it could submit the data to alternate versions of the program in parallel just to compare results. Perhaps it could begin to guess, based on follow-on results, if certain data would be likely to produce errors or have some other result of significance. Alan turing proved that an algorithm to solve the halting problem cannot exist - that is, given a program and its input, there is no general algorithm to determine if the program will halt or run forever. The reason for this, I decided, is that the program is not a thing, but a series of actions. The undecidability of the halting problem is analogous to predicting the future, and the program can only be seen in retrospect - the actual sequence of individual instructions that have already happened. A program is structured in time, not in space. What we think of as a program is really a set of possible programs, or a set of possible sequences. Apparently, what’s not possible is to enumerate or count this set.

A lot of programming languages are built around our mental model of structuring space. A “spaghetti” coding style, for instance, is perfectly fine and in truth indistinguishable from everything else - to a computer. But humans don’t execute code, and as writers of programs we need structure to help distinguish the before and after, the setup and the payoff, the “flow” as a whole. We need models.

Well, I have a model, but it doesn’t come with a programming language unfortunately. I have come to think programming languages will, in general, be quaint one day. Programming languages in general have many problems, for instance - they’re deeply separated from the process one uses to write programs, and deeply separated from the activity which occurs “in the field” while the program is executing. Nature, for all its unbuildable complexity, has no such separations: the thing is the process and it’s always “online”. The tree can’t be separated from the process used to create it (growth), and it’s always running, so to speak, in one big feedback loop interacting with its environment. You could say that the DNA “describes” the tree, but again, there’s no way to take DNA and calculate a tree without doing the actual tree growing. Oooo, the halting problem again.

We need to somehow get away from programming technologies that think of programs as singular, static, brittle abstract descriptions of an undecidable future, separated from the past, the present, the process, the people, the environment, the data, and history.

Until I have a better guess about what that might be like, I’m hangin’ in PHP and Ruby and having good old-fashioned fun writing some code.

Oh yeah, and thinking up an alternative to “holt research” which is kind of a limiting and obfuscating name. what the heck was I thinking…