Clearly, he didn’t position himself without some self-education. He had good reasons (stock market was languishing) to uncover information about the next cycle. As a practiced entrepreneur he knew both how to form and promote the new business: it was really only a question of figuring out which business would be the most profitable. He’s now quite passionate about the data he’s collected, and in helping others to profit from the information.

But you don’t achieve that kind of success without some up-front costs and research, together with the tenacity to carry through on the plan.

Recently, I’ve been trying to figure out what is the best manner in which I can use my existing capital (education about programming, dedication to reading/learning more, and passion for clearly explaining it to others) to build myself a stable future. On the one hand I could get a regular job either as a programmer at a large tech company (producing more for them that I receive in salary) or as an instructor a college/university (collecting considerably less in salary). But neither of these options gives me the autonomy I desire. Besides which, I think that Kahn Academy, has shown us that a revolution in education is afoot.

So, my current plan is to find a way of effectively educating people about programming: to provide them with the skills that allow them to join the class of highly compensated professional programmers. If I can uncover a mechanism that scales, so that revenues are less a function of the time I spend talking and more a function of the skills instilled in others: then I think I can build a stable, reliable income. The mechanism that scales well seems to be short self-contained videos about language features and design patterns accompanied by an XP workshop to build the interpersonal skills and practice.

What I learned from Mike: Building a business on the boom cycle leverages your gains.

Key to this topics is an interesting observation, for the syntax of any language to have meaning, there must exist an interpreter. For spoken languages, the interpreter is a brain (conventionally human, though the statistical models of machine learning experts are pushing the capabilities of electronic brains). In my own field of computer science, we’ve recognized that via a side-effect of the Church-Turing Hypothesis, formal languages can be turned to inspect themselves in a Strange Loop.

Lisp gives the most compelling example of this structural curiosity: For the underlying data structure of Lisp programs, the list, is syntactically represented in the exact same manner as Lisp programs themselves. This property makes the language homoiconic. The advantages are philosophically far-reaching: it makes very easy the ability to have code-writing-code, because a program can treat another function as data, manipulating it and restructuring it, until a new function is produced as a result.

Of course, if the system is allowed to point at itself, we have self-modifying code. And all the dangers, and advantages, and clever tricks that implies. I bring up this point, because of that last item: the difference between a document and an application is steadily blurring on the Web. It started with a desire for documents to have some level of interactivity, and has crescendoed into mail, maps, and even gaming (thanks to HTML5 canvas). But what’s really going on is, JavaScript, which is embedded in a document, has access to the document, and can modify the contents on the fly, in response to user input. It’s a self-modifying document (that can interact with the world through REST API’s, XmlHttpRequest, post/get webforms, etc).

[I just want to bury in here a mention of the Guidelines on Active Content and Mobile Code which focuses on the security implication of readily available, barely containable, documents with embedded code ]

Even if JavaScript, by chance, has some self-describing features as witnessed by JSON. I think the better medium would have been something Lisp or Scheme-like. We could port a publishing framework such as Skribilo to the web pretty easily. Just write a scheme interpreter in javascript, provide hooks for the html generator backend so that connects to its own page, and ship! Because Lisp and Scheme have some better theoretical underpinnings (due to their closeness to the lambda calculus) we ought to be able to get better security by moving our documents to such a form. At the very least though, we will definitely have an easier time maintaining our document/app chimeras.

Alan Kay has a nice talk, Programming and Scaling (also at LtU), where he carefully, and patiently explains that our software today is tinker-toys. We haven’t raised our level of consciousness, we aren’t innovating ideas, and our languages aren’t powerful enough. I like this because, at the end of the talk he demonstrates how to stitch pieces together with greater effect: OMeta.

Ungar has a video given at Stanford called Self and Self: Whys and Wherefores where he shows clips demonstrating the Alternate Reality Kit . The ARK, in my opinion, represents alot of what Kay has been doing in Squeak. Ungar, uses these clips to argue that “simplicity begats uniformity begats malleability” (Randy Smith). When designing a system, we should try to keep it small and elegant. This is not just an aesthetic issue, but it’s an engineering complexity issue. By striving to keep the system small, we factor out the core ideas behind the system. This helps use to explicitly identify the underlying similarities of what we are trying to model. This uniformity make for a better system, and gives it a cohesive framework. You’ll notice the same lesson is available from Unix, where Thompson and Ritchie credit the idea of ‘piping’ with a fundamentally better means of program interactivity, and the ‘file object’ as the enabler. (The file interface was later improved in the Plan 9 OS). The uniformity can also be brought to the fore, by language. A core language for expressing the core ideas. You should also not add to the design of the language by looking at clever examples that show off the feature. Instead, step back, and see if the new rules fit in with the principles of the system.

These demos of old systems (especially the Mother of All Demos (vid)), really pack a punch. It kills me to think that we’ve been getting it wrong for so long. The mediocre triumphs because our brains are too slow. As Kay observes in the talk above: We can’t conceptualize our future except by baby-step-iteration of the present. This is a sad state of affairs.

Steve was kind enough to point out a really nice XML logfile example, which I reproduce here:

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<!DOCTYPE log SYSTEM "logger.dtd">
<log>
<record>
  <date>2005-02-21T18:57:39</date>
  <millis>1109041059800</millis>
  <sequence>1</sequence>
  <logger></logger>
  <level>SEVERE</level>
  <class>java.util.logging.LogManager$RootLogger</class>
  <method>log</method>
  <thread>10</thread>
  <message>A very very bad thing has happened!</message>
  <exception>
    <message>java.lang.Exception</message>
    <frame>
      <class>logtest</class>
      <method>main</method>
      <line>30</line>
    </frame>
  </exception>
</record>
</log>

(log
'(record
  (date "2005-02-21T18:57:39")
  (millis 1109041059800)
  (sequence 1)
  (logger nil)
  (level 'SEVERE)
  (class "java.util.logging.LogManager$RootLogger")
  (method 'log)
  (thread 10)
  (message "A very very bad thing has happened!")
  (exception
    (message "java.lang.Exception")
    (frame
      (class "logtest")
      (method 'main)
      (line 30)))))

What’s super-amazingly-awesome about this transformation is three-fold:

1. The transformation is structure-preserving.
2. The syntax is orders of magnitude simpler.
3. The tags can be interpreted as Lisp functions.

Let’s focus on these in more detail:
Because the transformation is structure-preserving, the transition is theoretically achievable. The Web is currently a huge stinking polyglot of HTML, XML, XHTML, JavaScript, XHTTPRequest. It’s been festering, and each time someone scratches an itch, we all have to deal with that solution and it’s interactions with existing technologies. Right now we have a huge Tower of Babal, and the web browser has to support it all!

In my work as a web security researcher, I’ve come to the conclusion that the root of code injection attacks is precisely this polyglot monstrosity! If the web had a simpler, unified syntax for all it’s technologies, many of these problems would go away, and the remaining ones could be more easily mitigated. No more special cases, means less buggy code, fewer opportunities for things to go wrong, and a lower profile exposed to attacks.

Finally, because we’ve encoded the HTML data as a set of Lisp lists: the document can easily become self-modifying! HTML was envisioned to hold static documents, and roughly describe their structure to a browser that would render it. This worked well back in the early days, when all we had was some ascii pr0n, Star Trek lore, and home pages of CERN employees. But over time, as more people started using the web, we craved more exciting things. For example all the people on Geocities wanted that <blink> tag that made we want to scratch out my own eyes by prevented that by triggering an epileptic fit.

Eventually, businesses got in on the action. And they had frighteningly different demands: they wanted more automation, they wanted glitz that would attract users. It wasn’t enough to have a server-side script create and deliver a page based on what’s currently present in the inventory database. No! What they wanted was User Interaction. How do you make HTML more dynamic? You have to give it the ability to self-modify. But HTML isn’t a programming language, it’s a document layout language!

Enter JavaScript. Netscape (now Mozilla) birthed a language that would allow HTML pages to self-modify and self-introspect, and respond to user interactions. People, Businesses, Everybody just ate it up. There’s more JavaScript now than any other language.

Not only has the introduction of JavaScript compounded the polyglot problem, it introduced a whole new class of security risks because of the self-modifying capabilities. Now, your browser actually downloads code from anywhere on the web, and happily executes it. Demand for dynamic content so overwhelmed folks at the time that nobody seriously questioned the security risks! A very common attack nowadays is the XSS attack. If you can find a way to get JavaScript onto a page (say by posting it on a web forum) then you can take control of every browser that sets eyes on that page. This was how Samy (my Hero!) took out MySpace.

I’m not going to spend any more space here arguing against the idea of a self-modifying document. It’s way too late for that. AJAX applications like maps and mail are way too useful.

Let’s look at where the web is currently headed. I’ve heard about using web architecture as a service. I’ve heard about it using it for application delivery. The natural extension here is that your browser becomes the next operating-system in a box. But is this nasty polyglot, ad-hoc model of languages and their unholy spaghetti of interaction really the way to achieve that? It’s probably going to happen anyway. We can already see how: nobody writes HTML and JavaScript now, it’s all machine generated. Generated by Rails, and other web frameworks. When machine architectures became too tedious, we stopped programming assembly. We let the compilers figure it out. Now that web programming has become a nightmare, we turn to the frameworks to save us. Let the frameworks figure it out. The frameworks have become the compilers of the web.

But if you are really just going to machine generate so much… Why stick with the crufty interfaces? Why not replace it with, what I now consider the best data-interchange format of all time? Is Lisp really that bad?

There’s one other feature that Steve mentioned in his article that I haven’t addressed yet. Suppose that we decide to replace that HTML with Lisp, then what? How do we get back those dynamic pages? Well, look at that example again. Go on, look. I’ll wait.

It’s in Lisp. That means it’s potentially executable. Each of those entries, log, record, date, etc… can be a Lisp function. For HTML, we’d have the DOM structure, and each item in it would be executable. Some convenient hooks into the renderer, and your Lispified HTML renders itself! Another hook, say for the script tag, and your document becomes self-modifiable! We’re missing none of the dynamic content, just making it easier to parse and manipulate. I think if we switched we could build cathedrals on this stuff!

So please! What the web really needs is for this hideous architectural and syntactic nightmare to be slain like the monster it’s become! Since HTML really started as a document encoding format that focused on hierarchical structure, there’s no reason we can’t switch this to Lisp, like in Yegge’s logfile example. We lose none of the structure, and gain in simplified syntax. We loose none of the functionality, and gain enormously in our ability to parse, manipulate, transform the document. Further, since Lisp is so elegant, we can also do more of the analyses required for securing, optimizing, and jit-compiling.

Last week, while I was working on re-writing that compiler, I decided to upgrade my system (I felt oppressed by my software). I usually advise all my friends: “Don’t upgrade your computer, it will break everything.” It would have been good to follow my own advise. After the upgrade, grub was all wonkers and I couldn’t figure out how to fix it easily and get back to the compiler work. So, I figured the quickest solution was to completely re-install the system.

Easiest path to getting a new system, that has close to the same functionality of the old system is quite simple when you don’t have to worry about making extra backup copies of your stuff! I broke the mirror RAID, and installed a new system on one of the drives! Then any settings that I don’t quite like, or configurations that need to be maintained (such as the one for this website, and for Xorg) I can copy over when I identify the problem. When everything is all hunky-dory, then I can also re-establish the RAID.

Best part about splitting the root from the /home, is that all my user preferences and settings don’t have to be touched during the entire process! As soon as all the packages I wanted were installed in the new system (via dpkg --(get|set)-selections) I could simply login and pick up where I left off.

The total time before I could get back to programming: 1/2 day. I love Linux!

Last year I bought myself a nice quad-core desktop machine, that required its own assembly. I had to get a specific case, so that would hold 6 HD’s, 4 in a RAID5 and 2 in a RAID1. I remember spending probably about 2 weeks going through all the options and choices, doing price/performance comparisons, etc, etc. My desires are really too specific for anyone but myself to buy a good Xmas present. That machine, is still working today, serving up this website, and hosting a large collection of media. Since I purchased it I’ve wanted to run use the quad core for heavy-duty computing, but only wound up doing that once. I still have (long dated) plans to do stock market calculations though!

So, today and yesterday I spent several hours browsing the netbook offerings. I’m pretty sure that I want one of these things now. Last year, the market didn’t quite fit my needs. What I’d really like to have is

• a decent keyboard
• HD screen 1366×768 resolution, with LED backlight
• Long battery life
• Built-in GPS
• Wifi, 802.11a/b/g/n
• Bluetooth, even though I have no bluetooth devices
• magnetic power plug, but Apple seems to have the monopoly on these, and isn’t licensing
• Internet everywhere, without paying hideous $30+/mo. service charges
• a Solid State Drive, because 5400rpm makes virtual memory paging take too long
• a processor that can actually do work

It seems that enough of these requirements are fulfilled by the Acer Aspire as1410-8414. While HD video playback isn’t as good as a normal desktop, it’s really the screen size that I care about. I need that space for plenty amounts of text. I assume that if the provided HD is too slow for my tastes I can upgrade in 6months to a SSD, and more RAM. My current laptop, Toshiba Satellite U205-S5057, has a Core 2 Duo, and has held up quite nicely for 3 years now. It’s unfortunate drawbacks are some finickiness with suspend/sleep, and battery life. I think that the season is right for an upgrade. I’ll be downgrading to a Core 2 Solo, but the higher number of pixels, and longer battery life make it all worthwhile.