I've been really bad about blogging lately. So much to do, and so little time in which to do any of it. One thing sure remains constant: time keeps ticking away.

Over the last couple weeks, I've been working on a book proposal and outline. It got submitted last night. I was approached by a publisher a few weeks back to author a book, and if all continues going well I'll likely take the offer. I'm particularly excited about the project albeit a bit scared about the time commitment.

Progress on my Scheme compiler has been minimal because of the book effort. This is really a shame because I'd spend all day working on it if I could. Like I said, time is something I'm short on at the moment.

I began writing a paper which I'd love to complete, but that will likely take some time. It explores using structural equivalence for type matching and operational subsumption, foregoing the artificial inheritance policy that OO slams on types. I'm particularly interested in exploring how this would enable rich ecosystems of types to borrow and share implementations from each other at runtime, introducing mutations in parallel. Basically, an evolutionary type system.

Microsoft has been going well, although it obviously eats up most of my time and energy. Mostly this is a shame, simply because I have research work like my Scheme compiler that I am completely in love with. The energy people have there is just sickening at times, and it's difficult to remain in the game 100% of the time. I've found that it's easy to fall behind and lose effectiveness, simply because of a loss of focus for a minimal amount of time.

I had one of those "you're a moron" moments today. Was sitting there, and suddenly some guy shows up at my office door. I was so involved in what I was doing, my brain just couldn't do the context switch fast enough. Paraphrasing... "Hi, I'm Herb. Do you agree with the premise of the email I sent earlier?" I responded, "The value type finalizer thing?" Blank stare between the two of us. Him: "Value types don't have finalizers..." Perplexed, I thought about it for a moment. Ahh, yes... "Oh, disposable value types." Turns out it was Herb Sutter, a C++ Architect and smart dude. It always amazes me how whenever I open my mouth I make myself look like an idiot.

I went to a friend's place last weekend to hang out. It's great to unwind and let the noggin' relax for a little bit. Unfortunately, it again reminded me of my lack of a strong long term career goal. I used to think that it was being a (successful) entrepreneur, as various business topics have always interested me (such as competition and macro-economics). However, computer science is my passion, and academia and/or a research environment seems like a natural fit. I thought of this because many of the folks at the gettogether were PhD's and there was at least one professor from UoW. I wonder every day if that's my real calling.

Chilled with KitG, JoelPob, and AMoore tonight for a couple beers. Two Aussies and a New Zealander. All on the same team. Who woulda thunk it? Good fun.

Anyhow, it's only 1AM and I've got some reading to do!

Another one of those "What kind of person am I?" surveys... courtesy of Mr. Sells.

our distinct personality, The Prime Minister might be found in most of the thriving kingdoms of the time. You are a strategist who pursues the most efficient and logical path toward the realization of the goal that you perceive or visualize. You will often only associate with those people who can assist you in the implementation of your plan. Inept assistants may be immediately discarded as excess baggage. To do otherwise could be seen as inefficient and illogical. On the positive side, you can be rationally idealistic and analytically ideological. You can be a bold decision maker and risk taker who can move society ahead by years instead of minutes. On the negative side, you may be unmerciful, impatient, impetuous and impulsive. Interestingly, your preference is just as applicable in today's corporate kingdoms.

I especially love the bit about being impatient and impulsive. Me? Naahhh...

We just had a DevDiv get-together (that's Developer Division for nonconformists out there)... free beer, and a couple hours to wind down is never a bad thing. At one point, we had a discussion burning away about the optimal number of children a couple should have. In the midst, the following gem popped up:

Brad: I've been successful at convincing her we should have a prime number of children.
Anthony: Yes, then at least you could store them properly in a hashtable.
<ensuing laughter>

Good point, I thought.

Yup, another one of these book posts... I've actually found the process very revealing for my own self; I very seldom take a structured look at my activities, and I think research and reading is one that deserves structure. The next step is to plan ahead rather than simply analyze prior trends.

How to Solve It: Modern Heuristics by Zbigniew Michalewicz, David B. Fogel

10 of 10. This book is easily within the select few books that I've enjoyed 150%, page for page. The general topic of heuristic-based problem solving strategies is discussed, including search- and network-based solution techniques, evolutionary approaches, along with plenty of fundamental information on problems, modeling, and the process of devising solutions. I felt engaged throughout, constantly presented with example problems to keep my brain active. Although some relatively elementary math is used to express concepts, the book is surprisingly easy to read (considering the density and depth of the material covered). Just as a teaser, I'll go ahead and offer up one of the simplistic examples found early in the book: Mr. Smith and his wife invited four other couples for a party. When everyone arrived, some of the people in the room shook hands with some of the others. Of course, nobody shook hands with their spouse and nobody shook hands with the same person twice. After that, Mr. Smith asked everyone how many times they shook someone's hand. He received different answers from everybody. How many times did Mrs. Smith shake someone's hand?

microserfs by Douglas Coupland

8 of 10. This was a gift, and was read within a couple days of receiving it. The book is basically a novel that reads like a pathetic Microsoft employee's journal. He and his friends decide to be not-so-pathetic, and decide to join a 90's-style start-up, but still end up being pathetic. I'm still unsure what sucked me in, as I'm typically not a fan of works of fiction, but perhaps it was the truthfulness of the Microsoft cultural references that did me in. It's a bit frightening when a fictional book reads as though it's a diary of your own life... oh, and it was written ~10 years ago! Now, I'd like to think that I'm not as sad as the characters in the story, but perhaps I'm in denial? ;)

Waltzing with Bears: Managing Risk on Software Projects by Tom DeMarco, Timothy Lister

7 of 10. For that spreadsheet-oriented part of your brain. Covers some fairly straightforward (duhh) concepts that, as in most books written on topics of business and management matters, should be obvious but often aren't. And no, this book doesn't advocate for eliminating risk entirely, quite the opposite actually. Which is why I found it interesting: it is primarily about managing and mitigating the negative consequences that could result from making (and managing the implementation of) risky decisions.

Joel on Software: And on Diverse and Occasionally Related Matters That Will Prove of Interest to Software Developers, Designers, and Managers, and to Those Who, Whether by Good Fortune or Ill Luck, Work with Them in Some Capacity by Joel Spoelsky

7 of 10. Most of this material is available right on Joel's weblog, but for those who prefer killing trees (which I do, not for the killing trees part but rather the yet-to-be-widely-understood preferable feeling of holding a book in one's hands) this was worth it. His style of writing gives some people heartburn, but if you take it for what it is, it's enjoyable. So what is it? Well, a collection of op-ed pieces on technology from somebody with a respectable amount of experience and success in the software industry. Luckily, you can get a good taste of his style by reading his weblog and be at ease knowing the book is significantly less expensive than your average book covering the subject of computers.

In Search of Stupidity: Over 20 Years of High-Tech Marketing Disasters by Alan MacFarlane, Iris MacFarlane

9 of 10. A classic tale of foolish mistakes that have sunk entire software- product units and/or companies over the years. I burst out laughing several times, and still can't believe that many of the stories are true. I find that learning from other peoples' mistakes is often more valuable than digesting theoretical prose, especially when it comes to business advice. This book serves that purpose perfectly.

From Airline Reservations to Sonic the Hedgehog: A History of the Software Industry by Martin Campbell-Kelly
	8 of 10. A very well-written historical account of the software industry, and (imho) an indispensable resource for attempting to understand where we've been and where we're going. This fell into the category of "once you start, you just can't put it down"... for me, at least.

I've also been particularly enjoying a set of Don Syme's [MSResearch] publications. I found the coverage of ILX very insightful, and particularly relevant to my current Scheme compiler effort (man, I need a freaking code name badly).

I've been happily hacking away at my managed Scheme implementation. Just a quick progress report. I'm ~50% done with my parser, a hand-crafted LR(1) top-down predictive kind of guy. I'm realizing now that this might have been a suboptimal choice as the Scheme grammar is fairly ambiguous at times and results in quite a bit of backtracking. E.g. take a look at how many freaking nonterminals start with '(' that can appear interchangably... Once I get this more baked, I might consider alternative algorithms as part of the optimization phase.

For those who are curious, I'm using this as my primary language reference.

My object model looks like this thus far:

Lexical tokens:

+ Token
  - EosToken
  - BooleanToken
  + IdentifierToken
    - VariableToken
    - KeywordToken
  - LiteralToken
  - NumberToken
  - CharacterToken
  - StringToken

Parse tree nodes:

+ TreeNode
  + ExpressionNode
    + LiteralExpressionNode
      - QuotationExpressionNode
      - SelfEvaluatingExpressionNode
    - ProcedureCallExpressionNode
    - LambdaExpressionNode
    - ConditionalExpressionNode
    - AssignmentExpressionNode
    - DerivedExpressionNode
    - MacroUseExpressionNode
    - MacroBlockExpressionNode
  - FormalsNode
  - BodyNode
  - SeuqneceNode
  + DatumNode
    - SimpleDatumNode
    + CompoundDatumNode
      - ListDatumNode
      - AbbreviationDatumNode
      - VectorDatumNode

The latter, as previously stated, is only ~50% complete. Still happy with progress thus far... Got a looooooooonng way to go.

Some people picked up on my reference to an obscure number grammar last week, so I figured I'd post briefly about my intentions.

I am cooking up a managed Scheme interpreter and compiler. There are still several unknowns at this point... for example, I'm not even sure what approach I'm going to take with regards to licensing and releasing the source (it's primarily just an academic exercise for my own benefit). My actual code generation story isn't fully baked yet, either. Regardless, I am keeping a sort of dev-log which I intend to transform into a paper or set of blog posts when it makes sense to do so. So these tough decisions should be well documented.

I'm hand-authoring the front- and back-ends, knowing fully that there are tools out there that could auto-generate much of it for me. Call me a control freak. The process has been very interesting thus far, actually (albeit a bit tedious at times... e.g. do I put one or two characters back on the buffer?). I'm continuously reminded of the age-old search for the perfect mix of generalized and specialized code.

The milestone I spoke of last week was successfully implementing the lexer and its ancillary components. I found some compliance scripts on the 'net which are proving handy for testing. When I say it's complete, I mean complete: it lexes any valid Scheme, and has an error-detection/recovery strategy that I'm fairly happy with. Took about 1.5klocs.

Granted, Scheme has a pretty straightforward lexical structure... the super-difficult bit is certainly the code generation. I think the biggest challenge for the entire effort will be getting acceptable parse/emit/execute performance when operating in interpreter mode (the default).

I'm working on a project really hardcore, and I've just hit my first milestone. I'll divulge more information as I make more progress.

For now, I'll simply note that what follows is the most freaking difficult grammar to represent numbers that I've ever dealt with:

<num R> --> <prefix R> <complex R>
<complex R> --> <real R> | <real R> @ <real R>
    | <real R> + <ureal R> i | <real R> - <ureal R> i
    | <real R> + i | <real R> - i
    | + <ureal R> i | - <ureal R> i | + i | - i
<real R> --> <sign> <ureal R>
<ureal R> --> <uinteger R>
    | <uinteger R> / <uinteger R>
    | <decimal R>
<decimal 10> --> <uinteger 10> <suffix>
    | . <digit 10>+ #* <suffix>
    | <digit 10>+ . <digit 10>* #* <suffix>
    | <digit 10>+ #+ . #* <suffix>
<uinteger R> --> <digit R>+ #*
<prefix R> --> <radix R> <exactness>
    | <exactness> <radix R>

<suffix> --> <empty>
    | <exponent marker> <sign> <digit 10>+
<exponent marker> --> e | s | f | d | l
<sign> --> <empty>  | + |  -
<exactness> --> <empty> | #i | #e
<radix 2> --> #b
<radix 8> --> #o
<radix 10> --> <empty> | #d
<radix 16> --> #x
<digit 2> --> 0 | 1
<digit 8> --> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
<digit 10> --> <digit>
<digit 16> --> <digit 10> | a | b | c | d | e | f

Where R is in { 2, 8, 10, 16 }.

10% down, 90% to go.

I have a relatively shnazzy home theater system... nothing extraordinarily special, but we have a dedicated entertainment room, a 57“ Sony widescreen display, and a Bose Lifestyle sound system. And, what do I use such toys for?...

Watching movies, of course.

Which movies? These ones:

• Structure and Interpretation of Computer Programs
  The classic MIT course, video captured from the mid-80s. It's amazing watching this how little has changed in the field of computer science since then. Yeah, yeah, different languages, some new fancy shmancy runtimes, APIs, and the like... but the foundation seems to be proving fairly rock solid. The accompanying Wizard book is available online in its entirety, as well as some wiki content on c2. Caution: downloads are massive.
• Dynamic Languages Wizard Series
  This series consists of three panel discussions covering language-design goop. Specifically, there's one for runtime, one on compilation, and another on language design. Definitely worth watching each once, perhaps twice. (Unfortunately, these are in QuickTime format. I actually installed that crapware just so I could watch these videos... what a man will do for his love of geekhood.)

Any other suggestions for similar online content out there? Thanks to Peter Drayton for the pointers to both of these.

(Yeah, yeah, using my DVD burner'd probably be significantly easier than my hack wiring... but, I'm a cheapo. Last I checked, blank DVDs are hovering in the low-to-mid $10s.)

There are a couple other DVD-based videos which I am particularly fond of, too:

Triumph of the Nerds Done by Robert Cringely, there are three primary documentaries on a single DVD, each of which details a particular step in the evolution of personal computing. For some reason, I have watched the entire series 5 or so times... it's just good entertainment! It contains interviews with BillG, Steve Balmer, Larry Ellison, etc. way back in the day... as well as the creator of the Altair! Oh man, I'm getting so excited typing this that I think I'll go steep a cup of tea and watch it right now.

Revolution OS Details the rise of the Linux OS and FSF/GNU, through interviews with Linus Torvalds, Richard Stallman, Eric Raymonds, among others. Contains a couple skewed perspectives (I recommend ignoring the narration), but all-in-all I found it informative.

Ants are very fascinating creatures. I've become more appreciative and aware of this recently, as the pages of the following books flowed past my eyeballs:

Emergence: The Connected Lives of Ants, Brains, Cities, and Software by Steven Johnson I bought this several years back (2001, I think), but just picked it up again for a read. It describes the concept of emergence, that is, when given an aggregate, the capabilities (far) surpass the sum of the capabilities of its individual parts. For example, consider ant colonies, in which individual ants are making decisions in isolation based on an extremely limited capacity for analysis and thought. When viewed in the aggregate (colony), however, each ant appears to be contributing to an extremely coordinated, thoughtful, and strategic mass. The author here attempts to be clever on too many ocassions, and the applications to technology are a bit stretched (IMHO). However, it lead me to look deeper into the behavior of ant colonies, and as such was a good “gateway“ read.

Ant Colony Optimization by Marco Dorigo, Thomas Sttzle Read this now. This book focuses on algorithmic techniques for approximation of NP-hard/complete problems, in particular Ant Colony Optimization (ACO). Out of disorder, chaos, and localized decision making, the simulation of ant behavior to attack classic NP-hard algorithms causes fascinating new approaches to problem solving and new approximate solutions to emerge. This is one of the best reads in a while.

As you've most likely already heard, Microsoft announced today that WinFX will target downlevel operating systems (e.g. WinXP and WS03) in addition to Longhorn. This is awesome news. For more details on our plan, I'll leave it to The Man Himself - David Treadwell. Chris Sells also has a great summarization of what this means to WinFX customers.

I'm extremely excited about this... the platform that I live, breath, and... well... y'know... eat, I guess... every day (WinFX, that is) will experience an elevated and accelerated adoption as a result. It'd be awesome if there was a simple switch we could throw that immediately gives everyone LH, but this obviously isn't reality. As a result, shipping on XP and WS03 means that we'll reach a broader audience in a shorter amount of time. ISVs and IT shops can get cooking with gas without requiring that 100% of their users be on the “latest and greatest” OS. Goodness if you ask me.

Update: Soma offers up some perspective, and Paul Thurrott gives some historical insights and opinions as to why this is a good move for the big house.