Here and now, I pay the bills by writing code and by trouble shooting code. I also write code to manage my web site, and sometimes just for fun. I spend more time programming than I spend writing, and I spend more time thinking about programming than I spend thinking about writing. So, I'm a programmer who writes. Someday I'll "retire" and be a writer who programs, but that's on the far side of two sets of college tuition.

However, I do find writing more satisfying than programming. It's partly that books and magazines are more tangible than software, and so they feel realer than software in an old-fashioned sort of way. It's also partly that a bad draft doesn't crash; it's just incomplete, ambiguous, or confusing. Rewriting is a process of improvement, and the emotional tone of each decision is 'yes, that is better.' There's some of that feel as you grow a prototype to a product, but development these days is largely a matter of using Other People's Code, and you don't spend a lot of time making decisions, you spend a lot of time figuring out how to do something, or why your code doesn't work when it looks just like the example. This is frustrating; I think this is why so many people report that programming's not as much fun anymore.

However, the real answer is "Neither." Paying work aside, I spend much more time in C# than in Delphi or Delphi for .Net. This is partly because when I'm exploring some part of .Net that's new to me, I want to know that any problems are on my end, and not in a preview compiler. It's also that I do find that I like C# in much the same way and for many of the same reasons that I've always liked Delphi, and I do think there will probably always be more C# jobs than Delphi jobs.

Short answer: I like it an awful lot. I hope it flies.

Longer answer: I think the framework classes are really well done. They're very clean and flexible, and can be used in all sorts of ways. I'm more productive with the FCL than with the VCL.

I really like the way garbage collection changes programming. You don't have all that Free What You Create overhead, so your code is smaller and clearer and easier to write. Garbage collection also makes programming even more object oriented. You want to write a function that returns an object? No problem - you never have to worry about who owns an object.

I'm particularly taken with the way everything is either already an object - like arrays and strings - or is a value type that can be boxed into an object. This makes for very flexible collection classes, and makes for type-safe code that's small and easy to read, without lots of 'wrapper' boilerplate. Anything that reduces boilerplate is good, since boilerplate is very bad - boilerplate slows comprehension and increases the number of places you might make a mistake.

And, of course, .Net still promises to provide a much larger set of customers for my programming and readers for my writing. It's a bit surprising that .Net hasn't really taken off and that I still have to say "promises to" instead of "does," but I don't think this has much to do with the quality or ultimate prospects of .Net; I think it's pretty much a matter of the weak economy and the way people are avoiding big new initiatives right now.

That depends both on my customers and on Danny Thorpe. I rarely get to start a system from a spec, so I rarely get to choose a language or environment. Most of my paying work is as part of a development team, or as a trouble shooter, and those decisions have already been made.

Right now, with C# solid and DfN still under development, I find that I do my .Net programming in C#. While there are Delphi language features that I miss in C#, there are also C# language features that I miss in Delphi. Overall, I find that C# offers just about as much protection against careless errors as Delphi, while being a bit less 'fussy' - I particularly like the way you only have to declare a method once in C#, and can actually use a method before you declare it. To me, this leads very naturally to a style where a public method heads a folding region, with the private code that implements the public method tucked below it in the folding region.

However, Delphi remains a higher level language than C#. It has features like class of that save you an awful lot of code, and that take a fair amount of behind the scenes work to implement under . Net. Similarly, where in Delphi for .Net you pass a delegate to a method just like you specify a method parameter in Windows, simply by specifying the name of a method, in C# you have to explicitly new() the right type of delegate object, passing the constructor a (yes!) name of a method.

I don't like boilerplate, so if DfN code involves a lot less boilerplate than the equivalent C# code, then I'll tend to drift back to Delphi, at least for my personal utilities and recreational programming.

The greatest advantage is probably the way certain large classes of bugs are much less common or are even just not possible. No pointer arithmetic means no pointer arithmetic mistakes. No unchecked casts and no dangling pointers means no miscasting, which in turn means none of the memory corruption that miscasting causes. No need to free dynamic memory means a memory leak takes an active mistake like explicitly keeping a reference to unnecessary data, not a passive mistake like forgetting to free memory.

But if managed code is the greatest advantage, it's really only first among equals, and not all that far ahead of other advantages. The FCL is much cleaner and more consistent than the Win32 API. All languages, all layers of code, use the same component model, instead of multiple incompatible wrappers around the flat API. All languages, all layers of code, can use each other's records, objects, interfaces, and exceptions. Useful abstractions are baked into the system as primitives.

I think .Net could increase Borland's market share in development tools. Delphi could be the natural .Net language - higher level than C# and cleaner than VB. C#Builder's modeling focus might make for a much more productive C# environment than VS.Net.

But the battle for market share is not a battle that's going to be fought and won on technical grounds. Everything will depend on how Borland positions and prices its products. I don't really want to venture an opinion on the outcome, but of course I wish Borland well.

Santa Cruz, California, about a ten minute walk from the ocean. I'm originally from New Haven, Connecticut, but I moved to California when I graduated college, and now I've been here over half my life.

I like Santa Cruz. It's a college town with a great climate, and so it has the variety of people of a medium size city, with a lot less crowding and stress.

I first programmed in Focal - a Basic-like language - on a PDP-8 in an eighth grade "Computer Club." I first took formal programming classes in college, but resisted majoring in CS because I wanted to get a PhD and go into research, and saw computers as tools, not as subjects of study. Also, at the time it felt wrong to take 'vocational education' at a liberal arts institution like Yale.

When I graduated, I thought I'd go back to grad school to do AI within a few years, but somehow this never went beyond taking the GREs and sending for a few admissions packets. When it came time to write convincing essays about why I wanted to do research, I found that I didn't really want to, anymore.

It'll be thirty years this fall since I first encountered that PDP-8, but it's twenty two years since I graduated college and started programming professionally.

Since I majored in philosophy and had a certain ambivalence about computers in college, I didn't have a job lined up when I graduated. Still, programming was undoubtedly my most salable skill, so when I moved to San Francisco, I started calling every computer company in the phone book. I got a job writing APL in the Oakland office of stsc, an APL timesharing company. After a couple of years, I found myself in LA, in their 'internal consulting' group. I liked that job but hated LA, and quit to make my fortune selling PC software.

I started using Turbo Pascal, and stuck with it through all its incarnations through TPW primarily because - as an independent programmer - I did have the luxury of selecting my own tools, and always preferred TP's tight edit-compile-test cycle over the slower C or C++ cycle. I never made all that much money writing "shrinkwrap" software, but I did learn a lot, and started writing articles.

Around the time of Delphi 1, publication started leading to contract work, and I found that I vastly preferred freelancing - even with its boom and bust cycle - to independent development, so that's what I've done to this day. At about the same time, my magazine articles had grown from short tips to multi-part feature articles and book chapters, and I realized that a book was 'just' one chapter after another, and that I could write a book.

Turbo Pascal, starting with TP1. APL before that. In college, mostly Lisp, C, and APL. In high school, Basic, Focal, and a very little assembler.

It would depend on the young person, of course. Programming has changed so, and I wouldn't really recommend it to the sort of person I was, who preferred math and physics to chemistry and biology. Time was when programs were largely self-contained, and programming was a matter of making abstractions real. You built just about everything yourself, from language constructs and the simple libraries of the day. It was like physics that way: Master a few key concepts and you could do anything. It's much more complex, these days - more like biology or chemistry. It takes a different sort of mind to enjoy this sort of work, and I'd only recommend programming to someone with the right disposition.

Also, time was when programming was a sort of haven for the mildly autistic. Programming skills were so scarce that eccentricity and social deficits were no bar to a successful career. These days, programming skills are much more common, and are becoming commoditized, with routine stuff increasingly sent to Asian cube farms. This means that social skills are more important than they once were: I think I'd steer a geeky kid to newer technologies like materials or biotech.

Biology, organic chemistry, economics, sociology, perhaps even history or political science. Any discipline where they get experience working with complex, interdependent systems.

A good, solid grounding in math and statistics. You can get by without any math beyond algebra - if you only aspire to routine database apps. A student who thinks that Google is more interesting than a shopping basket, or that digital music instruments are a lot more fun than microwave oven controls, should take a lot of classes that have calculus as a prerequisite.

As far as specific languages and technologies, it's obviously going to be helpful - right now - to have both Java and .Net expertise. Whether this will be true in five years - or even two - I really don't know.

Second place would still be the pager API that I did for Socket, back in the '90's. This came to me in a pretty inchoate state, so I was able to have a large influence on the defined API. That was fun, of course, but I think it's more important that it was the first really test-intensive project I did. This was years before JUnit, DUnit, or NUnit, but I wrote a test harness and lots of tests for every API entry. It came in well under budget, and everyone was very happy with the quality. The pager cards themselves never sold very well, but that's a different story entirely.

I've also found that current presentation software is really good when you know in advance exactly how the talk will go, but is not so good about including optional material. If one audience has different tastes in details than another audience, you pretty much need two different presentations. I'm playing with some ideas about how to handle alternatives, and how to take advantage of all the laptops with wifi in the audience. Still just ideas - not even a prototype - and I don't really know yet where I'll go with this. Though I'd be happy enough if Microsoft hired me for PowerPoint® ideas.

I like to go for walks along the ocean at night. When we lived on the other side of Santa Cruz, there was a beach that was maybe a mile and half long at low tide at the right time of year, and I pretty much named the company for walks along that beach. Where we've been for the last eight years is much cliffier and the beaches are smaller, but I've kept the name because it's distinctive and not tied to any one sort of business.

I try to think it's funny when I find I made some really stupid mistake. Otherwise I call myself names.

As a class of experiences, I love the way a model shifts about, feeling wrong, feeling strained and stretched, until you've factored each function into the right place. In my teens and twenties, I used to visualize APL code with matrices growing, shrinking, spinning &c in my head. LISP was beads moving back and forth on a shuttle. I don't directly visualize anymore. Perhaps that's because the scoring function for object hierarchies has to take so many dimensions into account. Perhaps it's at least partly just because I'm older and running more on experience than analysis. Perhaps even a touch of Not Invented Here over UML. But I think the way I perceive better and worse representations as more and less strained is using the same sort of 'right brain' spatial analysis that visualization did.

This sort of 'whole brain use' makes for peak moments.

That would have to be XBBS, my dialup hypertext system back in the late '80's. This was based on a clever idea - that state machines make efficient multitasking systems - that let my TP3 DOS program run 5 users on a surplus Victor, a 5 MHz 8086. Unfortunately, I was still pretty young, and threw in lots of complexity to impress myself. Worse, I tended to test whole subsystems, not individual pieces, and I ended up with a huge (for the time) system that crashed a lot. I never did get all the bugs out.

XBBS taught me that the best way to fix a mistake is to either not make it in the first place, or to catch it right away. I later learned that the best way to catch a bug that you didn't catch right away, that's had layer after layer of code built on top of it, is to knock out huge chunks of code until the bug goes away, and then find it by turning things back on. I do still wish I could have learned these truths in a less painful way.

NUnit.

Just three things. Market share, market share, and market share. More Delphi users means more Delphi jobs and more Delphi contracts, and more people who buy Delphi books, and more good brains in the Delphi community.

Probably in a cube farm in Silicon Valley, writing server-side Java, wondering if .Net was the way to go.

Probably not very different. I get mail from people who follow some of my patterns, but I don't know what percentage of the user base that represents.

This varies a lot. When I have tight deadlines, it can be somewhere around twelve hours a day. When I'm between projects, it might be as little as two.

Varies, from maybe 30 to 90 minutes. I love Google News, and tell everyone about it.

None, really - I rely on Google.

I ring the changes on new features as they're introduced. I usually find that I exploit language features first as syntax, and then come to see the underlying ideas. Every so often I learn a new language, and similarly go from syntax to ideas.

I 'listen' for new buzzwords, then I Google for explanations. I read books that get cited enough. I watch the Borland newsgroups for buzzword trends, and check up on the promising ones. I also find that newspapers like The Economist, the NYT, and Google News are pretty decent sources of buzzwords and citations. They are never up to the second and they never report anything absolutely right, but the filters seem good and (sans Google) the writing first-rate.

Anders Hejlsberg. From TP1 through Delphi and now with.Net, he's shown design skills way beyond the norm, and he's had a tremendous impact on the industry.

Homeschooling is great for kids who are a standard deviation or two away from a few norms. Kids who would just get picked on in public school thrive in homeschool.

Maybe writing non-fiction, like Tracy Kidder, James Gleick, or Dava Sobel. Or maybe truck gardening, selling in Farmers' Markets. But probably I'd be a lawyer.

Here and now, in America. The world is richer, freer, and more interesting than it was 50 (or 100, 1000, or 10,000) years ago, and while the future may hold a long Golden Age with low populations, space elevators, peace, and prosperity, it could almost as easily be very gritty and dystopic.

Couldn't I just have the cash equivalent? I don't really think that most people are going to pay much attention to a middle-aged white American they've never heard of.

Programming Perl, by Larry Wall &c. So hard to read, the Everest of close reading. Syntax used before it's explained and terse, precise explanations that you have to parse very carefully. Not a book I would want to write, but a book I enjoyed reading. When you understand Programming Perl , you understand Perl.

I like dance music, and I like books that tell a story and show a world.

Picking an absolute, all-time favorite is hard. The Moon Is a Harsh Mistress is a very old favorite which I read over and over in my teens, and enjoyed reading to my then 12 yo son. (Stand On Zanzibar was perhaps #2 in that pantheon, and made a more difficult read-aloud, though Lord Of Light (#3, I guess) worked pretty well.) But I really loved Kim Stanley Robinson's RGB Mars books, in what I think is much the same way I loved Harsh Mistress. I loved all four of the principle characters in The Moon Is a Harsh Mistress in their way, and I loved the mix of politics with details of Lunar life. The RGB Mars books similarly combine hard scifi with lefty politics and characters that feel very real: When I was reading it to my son at bedtime, we both found ourselves talking about what various characters would do, were they present; we both even found ourselves dreaming about them.

I also have to put in a plug for The Odyssey, which I seem to read every five to ten years. It seems to me to be the first story with characters who still feel real - Gilgamesh and other older stories feel more ritualistic, more tribal - and at the same time, I love the details of Bronze Age life.

Pasta with tomatoes and basil.

Red wine.