The coder is the one on the hook for long nights, weekends, and stress-related health problems if the estimates suck. It’s in your interest to exert as much control over estimation and scheduling as you can. If you’re not making the estimate, someone is making it for you.

If you think about it, you’re opting out of an ongoing salary negotiation process. You’re going to work more for the same amount of money, and worse yet, you’re going to have to squeeze that work into the same amount of time, under stressful conditions. Why would you do that?

McConnell’s “Software Estimation” book addresses this problem of wildly inaccurate early estimates quite well. I highly recommend it. In a nutshell, estimates need to carry error bars, so early estimates would be given but with a disclaimer of +/- 100% (or more!), and later estimates get closer to being correct.

You will have to manage expectations, though. Human nature leads to the shortest end of the date range becoming the remembered end date, the guess being remembered as a promise, and the latest feature set being remembered as if it were the original feature set.

This is a big reason to hire a good project manager: they’re there to facilitate the change control process, or planning game, or whatever you call it in your organization when the paying folks want more stuff, and the PM reminds them that need to pay more and wait longer in order to get more out of the dev team. A good project manager can make a huge difference to the stress level and likelihood of success of a project.

It’s psychologically icky for developers to have to participate in the estimation and scheduling process — “eww, it’s a non deterministic domain with lots of ill-defined inputs!” — and I’ve seen some managers play head games like “Oh, you need more time? I thought you were really good at programming… I guess not…” to try and manipulate developers into working nights and weekends out of a sense of guilt or wounded pride. But you need to suck it up and keep providing status updates and reminding people how the process works, because you-the-programmer are the expert on the nature of programming.

Yes, it’s more like Lewis and Clark or the Apollo project than like building a house, and there are just going to be a lot of surprises, but you can still provide a framework and exert a tremendous amount of control over how the team will operate. Things like whether you plan to build a technology proof-of-concept to make sure your architecture doesn’t suck, or whether you intend to spend lots of time writing automated tests and doing daily code reviews in order to control that horrible “bug fixing” phase toward the end are in your hands if you participate in the estimation process. You’re being offered an opportunity to make sure that all those important tasks like performance testing and cross-browser testing and writing an installation guide and an operations manual for the sysadmin get done. It doesn’t matter if the estimates for those tasks are completely wrong at first – what matters is that they’re on the list.

And really, the largest battle you’ll probably have to fight is the one over scope creep: we can’t launch until it has all the original features plus all these additional changes and new features perfectly working, but we need to launch tomorrow. That’s also human nature, and you need to train people to release early and often. Agile methodologies can help here, if you can get your software working and stable from a very early point in the project, and keep it that way. Then you probably have a launchable product very early, and you can just push highly-desired features into post-1.0 releases.

In any case, a list with a bunch of crappy numbers and low confidence factors is a lot better than no list, or a one-item list with a crappy number and an implied 100% confidence factor.

A closer examination, though, reveals that Kindle doesn’t solve the problems that caused prior e-book efforts to fail. It’s not better than a book in any way, and yet it costs more than a laptop PC and is nearly as complicated.

Let’s look at the key features.

600 x 800 pixel, 6″ diagonal grayscale display: This is probably the best part of the device. Those dimensions yield a 160 DPI resolution, which is quite sharp (compare to CRTs and LCD displays which typically have a resolution in the 72-96dpi range). I suspect that the display probably has outstanding contrast and sharpness, and that anyone attempting to objectively evaluate the device will be too busy drooling over the display to think about anything else.

“Simple to use: no computer, no cables, no syncing.” Well, why does it come with two cables, then? Oh, by no cables, you mean that there are two cables. Power cable, sure, because it’s more convenient than a book that way.

But what’s the USB cable for? Amazon CEO Jeff Bezos has a letter on the Amazon home page today that says “there is no software to install and no syncing required.” That’s true, as long as you don’t use the Audiobooks feature. If you do, well, then you need the second cable. (In that case it’s less convenient than an iPod because an iPod is smaller and cheaper, and has a color display. But an iPod won’t let you read books as clearly on a 6″ screen. So the Kindle is better than an iPod at that, I guess.)

“A copy of every book you purchase is backed up online in Your Media Library in case you ever need to download it again.” So, there’s no syncing, except for syncing with the server where the books are. And also there’s an SD card slot so you can keep track of what downloads are on which card already, and maybe accidentally keep multiple copies on multiple cards. So it’s not really syncing, it’s downloading. That’s completely different from what a Zune or an iPod does. (Except in the case of Audiobooks, when it’s exactly what an iPod or Zune does.)

You can email non-Kindle documents to your Kindle. That costs $0.10 each, and let’s hope you only need one version of that document, or else you’ll have to pay an additional $0.10 each time. Any Word documents will need to be converted automatically for you, which means that some percentage of formatting will be mangled in the process. So, there’s no syncing, which means that you have to be on top of making sure that the documents you wanted to have on your Kindle are manually re-emailed (at $0.10 per email) to your device each time they change. That’s much easier than syncing, yes?

Let’s make that absolutely clear: there are no cables whatsoever, other than two cables. There is no syncing, except for three different kinds of syncing.

“Navigation on both sides means both “lefties” and “righties” can easily use Kindle with one hand.” There are large next/previous page buttons on the left side, but only a next page button on the right, together with a back button. Shall we presume that the Back button and the Prev Page button do the same thing? Or do they mean that lefties and righties can go to the next page, but only lefties can go to the previous page?

It seems that as far as the controls, they have looked at what Apple has done with the iPod’s ultra minimalist design, and done the opposite. There’s a QWERTY keyboard, but it has “chiclet” keys, the space bar is in the wrong place, there’s a gap in the middle, a bunch of unused space around each key for no apparent reason, and an almost comical angling of the keys. There’s a weird LCD scroll bar on the right side of the main display, which is as tall as the main display, but is apparently physically separate. And there’s a big vertical scroll wheel.

Of course, the screen is a touchscreen and you can use your fingers or a stylus to select text. Wait. No? Oh, you can’t select text that way. It’s not a touchscreen at all. You just use the arrow keys… um. there are no arrow keys; there’s just backspace. Based on the photos on Amazon’s site, it looks like you hit Alt and then a number key in order to edit text, which you shouldn’t really be doing, because this is a book. Except, you also can use it to search, or annotate, or shop. So it’s sort of like a pen, or a black and white catalog, or a library. You might say it’s kind of like a laptop, but not really, because it’s supposed to be a super evolved book. But it has audio features, so it’s sort of an iPod, but not really, because it’s much too large to fit in your pocket.

Okay, so let’s assume that people in vast numbers will overlook ergonomic problems and aesthetic issues and the usual headaches of syncing, in order to get something substantially less functional than a laptop PC, which can be had for about the same price. (Let’s also assume that they don’t know that Sony makes a “Digital Book” reader that costs $100 less than Kindle.) There’s no reason to assume any of this, but let’s just pretend.

There’s still the property problem caused by DRM. Amazon’s Kindle page says that Fair Game by Valerie Plame Wilson has a list price of $26, but I actually clicked a couple of times to check this out. I can order it online, from Amazon.com, for $12.25 plus shipping. Then I can lend it to my wife, my friends, and then sell it to a bookstore or at a yard sale, or donate it to the library. I can get far more use out of a book at $12.25 plus shipping than I can for a $9.99 Kindle limited use license to read that same text on a $400 device.

(If I can be a little bit patient and wait for the paperback version, or for a lot more copies to be bought and then offered for sale used, I can get well under $9.99. I just bought a hardcover statistics textbook for $7.79 including shipping, just to avoid the wrath of Zed Shaw). List price? $123.53.)

Of course, the reason Fair Game is available for $12.25 in the first place is because it’s possible for someone to sell me a used book. I bet I could go to one of a half dozen local used bookstores and find the same book for a similar price. Or, I could just go to my local public library, and get one of the ten copies they currently have, for free. Again I could photocopy it, or let my wife read it before I return it. They own the physical books, so they get to do this.

(By the way, the library will also let me download time-limited PDFs for free onto my computer or brand new sub-$400 laptop. Yeah, they’re DRM encumbered, but they’re also free, and don’t require that I buy a special e-book reader.)

Clearly, buying physical books has some advantages. So what are the advantages are of electronic books? It’s definitely not financial. Here’s where the fun math applies: real physical books cost money to print, ship, store, and destroy. Electronic books don’t. Some large percentage of the cost of each physical book or magazine you buy goes to print, ship, store, and destroy the copies of that same book which no one ever buys. The printing and distribution costs of books are nothing to sneeze at; ask anyone who works at a bookstore. Electronic books, then, cost far less to distribute to customers. Why should we pay the same price for a license that costs less to make and sell, and gives us less in return, than a real book? That’s not even counting the very expensive reader device, which obviously will not last as long as a book will, and thus will need to be replaced in a few years just so you can keep reading the same book.

And that’s the biggest problem with e-books: Amazon is promising that when you “buy” a Kindle book, you will always be able to read it. This is not implied, it’s explicit: “Amazon is storing your personal library, which can always be re-downloaded wirelessly.” “…in case you ever need to download it again.” (emphasis mine) That means that they are promising you that someone will always sell you a reader device compatible with their format, and that you will always be able to put your “bought” books on that device. So, the file format and DRM and back-end service always will need to be there, and will always need to be available to you for free, or else the deal isn’t what they are telling you it is.

Would they pull the rug out like that? According to one early adopter’s comment on Amazon’s own side, they already did that with e-books once before. Google did the same thing with their video store. When a service can only survive if a massive end to end infrastructure is maintained, which pretty much defines all internet-based DRM efforts, the risk to the buyer of license revocation with no refund is very high.

Now, take a look at the film, television, music, and book publishing industry’s combined downward spiral and listen to their cries of despair. These are the people who are launching DRM-heavy services tied to closed devices. Are you going to entrust your entire personal library to what might well be a service that is cancelled in a year? What will you do with your $400 single-purpose closed hardware device then?

In short, Kindle is junk. It’s worse than a book in every way, and has no advantages whatsoever. I predict that no one you know will buy one, and that it’ll be discontinued in less than a year.

Android is a full software stack made up of many projects that exist separately from Android. The components of this stack are available under a variety of different terms: Linux is GPL’d; WebKit is LGPL’d; SQLite is in the public domain; FreeType is available via GPL or its own license. There are probably a dozen more little libraries and components that Android builds upon, all of which have licenses that need to be considered. It’s not possible for Google to just put a bow on the whole stack and say it all uses license X.

Google has released the Android SDK, which is the top layer, under the Apache license. According to the OSI list of approved open source licenses, this is an open source license. And yet, the reaction to Android from open source advocates is negative. Why? Well, the concern is that some implementation of Android will add proprietary code and/or remove standard code, fragmenting the platform. Since Google can’t rewrite the licenses of the underlying components of the stack, we’re really talking about fragmentation at the top layer of the stack.

The Apache license allows for parties who download the source code to alter it and then keep the altered source code secret, while distributing a derivative work. Contrast this with the “viral” GNU Public License, which obligates all parties who modify the source to either keep the modified software completely to themselves, or to distribute the source if they distribute a derivative work. Ignoring the case where a licensee simply keeps the derivative work to themselves, the GPL forces a web of innovation and collective advancement, whereas the Apache license encourages a central publishing model, where innovations are kept private and used for competitive gain.

Thus, Android applications designed to be compatible with Google’s platform could be made incompatible with a particular device, by a handset vendor who removes core Android APIs and replaces them with their own closed source alternative. This might seem like a paranoid fantasy of a small clan of open source zealots, but it’s not. This is the same tactic that Apple has successfully used to keep Mac OS X closed. Mac OS X rests upon a large amount of open-source code (some of which is also part of what Android is built upon), while requiring developers to code to Apple’s proprietary Cocoa APIs in order to make Mac apps. You can install Linux on a Mac, but then you lose the ability to run Mac OS X apps. You can build generic Unix applications on a Mac, but they look quite different from a standard Mac app, and lose a lot of Mac-specific functionality. Apple chose to make this possible, but compare this with the iPhone, which uses much of the same software underneath, but (as of this writing) cannot run a generic Unix app because Apple doesn’t want you to do this.

This same sort of situation is possible with Android under this license. Company X grabs the Android sources, dumps a few key APIs (maybe the GUI, network, and process management ones) and suddenly they have their own incompatible platform that can run on the same hardware but can’t share apps with the mainstream. Dump phones on the market (subsidized by monthly fees, as usual) and fund a few key apps (MP3 player, movie player, email/SMS, web browser) and users are stuck with that vendor’s offering, just like they are now. And this is just how telcos and media companies, both of whom are desperately trying to keep hardware and software platforms closed, think. The more closed a platform is, the more secure they feel about their profits, and the more willing they are to invest in it.

The only charitable explanation I can think of for why Google chose this license is the Apple explanation.

If Google were really pandering to the existing mobile carrier crowd, they could simply have released nothing, because another closed platform to build phones with and to write apps for is pointless. There are plenty of existing trunks to be locked in already. We don’t need somebody else to slap together a Linux distro for phones with a closed GUI on it. You can to go LinuxWorld Expo and probably find two dozen companies doing exactly that, and none of them is particularly successful. Google is too smart to add itself to this list of flops. It makes no strategic sense.

More likely, I think, is that Google intends to be Company X in my above scenario, putting themselves in the role of Apple by making an “Android Plus” premium platform that they put on the handsets they’re pushing. In this scenario, you can write your own apps to the reference platform and they’ll run on Google’s favored phone, but Google can still reserve the right to put all sorts of funky stuff on their phones without documenting it or giving developers or users any rights to it, and more importantly, without having to open source their special components so that non-Google devices could use them.

Sure, this is a charitable interpretation. They might just have screwed up royally, buying a company (Android) that wasn’t anything special and releasing something that no one other than journalists will pay attention to. But given that Google is betting $4.6 billion on the 700MHz spectrum auction in the U.S., I’m reluctant to simply write Android off as a “hail mary” acquisition.

There must be a larger strategy here, and I suspect it’s Google putting itself in the shoes of mobile carrier, handset OS maker, and service provider. Somebody else manufactures the handsets, of course, but Google owns and operates the whole experience from end to end other than that. You buy a Google device, pay a monthly Google subscription fee, your bits travel over a Google global network of wireless towers and a wired backbone, and you run apps on your Google phone that interact with Google back-end services. It’s a carbon copy of Apple’s iPhone/iTunes strategy, without AT&T in the picture, and with third party apps allowed on the phone, as long as they work on the already-published Android SDK. All Google has to do is to make a decent looking device and be less customer-hostile than existing U.S. mobile providers, and they’ll do well.

In this light, the partnering talks with existing mobile carriers is puzzling. It’s possible that they’re pitching a strategy that removes the burden of application development from mobile carriers, allowing them to be the billing companies that they really are, and putting Google in the position of being the provider of content and software. The lukewarm responses from these carriers is predictable; for the carriers to be involved as just bandwidth providers and customer billing service providers, there would have to be a careful negotiation of revenue sharing, or else the carriers will simply continue on their current, very lucrative course.

If they are planning to become a carrier themselves, then nothing can actually begin to happen until January, when the 700MHz spectrum auction actually takes place. There’s a closer December 3rd deadline for Google to reveal their plans. At that point we’ll know what they’re up to, assuming they’re actually able to buy the spectrum that would make it possible. Alternatively, this spectrum purchase could be a bargaining chip on Google’s part, which they do not intend to directly utilize themselves. Google would provide the spectrum, the handsets, the OS, the apps, and the services, and the carrier partners would provide the towers, the maintenance staff, sales, and billing.

Given all this, it makes little sense for Google to GPL the Android platform. They need to own it so that they can assure a prospective carrier partner that they will be the ones whose phones are being used by customers, in order to share revenues. If they were to open up the handset market entirely, the carriers would block any new entrants and Android based phones would be doomed.

Android is a huge win for developers. The SDK is already available for Windows, Mac-on-Intel, and Linux-on-i386, and it uses technologies that are already mainstream. Based on my previous post I am curious about whether Rhino, Jython, and JRuby will work on the Dalvik VM, but I have no specific reason to believe they won’t. This is exactly the sort of thing I was talking about when I said that layering on top of the JVM or .NET DLR would ease portability; the Dalvik JVM means that you can likely write a Hello World in any language that can compile down to Java bytecode and run it immediately.

OK, so it’s great for developers. So what? Developers don’t control the mobile market; carriers do. Handset makers would probably love to use Linux instead of paying a per-handset license for a closed phone OS; PalmSource/ACCESS and Palm, Inc. have already said they will move in that direction (though Palm, Inc is creating some confusion about whose Linux-based Garnet-compatible runtime will end up on future devices bearing the Palm OS name). But why would carriers want this?

It’s possible that carriers would like to see their value-added apps run on many different handsets without the cost of developing them separately for each handset they sell. Handset makers and mobile OS vendors clearly are making some money from consulting to carriers on these projects (somebody has to tell Sprint how to write the PictureMail app), so actually in this area handset makers would stand to lose money.

What carriers probably would like less about Android is that it would allow Google to bypass the carriers’ value added services and build their own ecosystem of mobile apps for Android-based handsets, which is exactly the point of Android. Who gets the value added dollars from customers? That’s what this is all about. Google is battling ISPs regarding Net Neutrality, and it comes back to the same thing. If a customer is going to pay for a service delivered from a server across a network onto an endpoint, there are at least four parties that want to get paid, and who view the division of revenue as a zero-sum game.

The server folks (Google, Yahoo, Microsoft, Apple, etc.) want to charge you for the subscription to their applications or for individual chunks of content. That charge may take the form of just showing you ads. Then they want to pay a flat rate for the bandwidth across the network to get to you, and will minimize that cost using the massive content delivery networks which they already have in place.

The network folks want to put a toll booth on that network that charges either the end-user or server folks (or both) for transferring paid content, or one that penalizes the end-user (bandwidth shaping) for buying a cheap connectivity plan and then trying to use it for transferring large media files from the server guys. The network folks also still think they can force the Internet to look like Cable TV, by putting up barriers to keep their users from using anybody’s services but their own, so their ISP customers also become their content customers.

The handset OS folks want to be paid to write those apps for the server folks and the network folks who want to also be server folks. They want to encourage developers (ISVs, or server or network big guys) to focus on their platform, thereby making it more attractive to users, thereby making it more valuable so they can charge a larger amount from each phone sold. These folks are directly in competition with Android, whether Google intends to attack them or not.

The handset manufacturers want to minimize the price of their phone (a free OS that supports tons of hardware components that they might use is a good start) and maximize the number of apps that will run on their phone. They should love this, although the most successful high-end handset makers who also use closed OS’s (basically every major handset maker) will not like it as much as the underdogs who sell tons of cheap phones. LG and Samsung say “hooray” while Motorola, RIM, Palm, Sony, and Nokia say “boo-hoo.” Their investment in special fancy phones and fancy apps for their chosen OS is undermined by the prospect of commodified hardware with carrier- or user-installable third party apps.

Users should be happy as well. Developers, as I mentioned, should love this platform, so users should benefit both from more apps and cheaper handsets, and probably also from more service offerings that will work with their handset.

The problem with all this is that as I mentioned in Technical Architecture is a Form of Investing, just because developers like something doesn’t mean it will win. If Google’s aim is to open up and commodify the handset market, they will have to fight the folks that are trying to keep the handset market closed and fragmented. That group includes all of the major U.S. mobile vendors, and the companies who make handset OS’s. The latter group is weak and easily conquered, with the exception of Microsoft; in this space, though, Microsoft is not strong enough to fight Linux and Java. The former group is extremely powerful and will not simply sell handsets that eliminate their chief source of revenue (proprietary value-added services that show up on your mobile phone bill). Nevertheless, these value-added offerings are generally awful and absurdly overpriced, so there is quite a lot of opportunity if someone can break through the carriers’ stranglehold.

The strategy that Google must follow is to convince an underdog mobile carrier to market an Android-based handset to consumers. Google has little strategic advantage to gain from replacing handset OS makers; they are a service and as such need to prevent the network guys from erecting that toll booth in front of Google’s services. To do that they will need to bypass the network guys, and a phone OS isn’t going to do that. Even a handset offering won’t be sufficient; look at Apple’s iPhone bricking debacle for evidence of that. The mobile carriers control the handset makers in the U.S., and Apple has had to learn that the hard way, screwing over their customers who dared to choose another carrier than Apple’s partner. You can bet that Apple wasn’t the driving force behind that decision.

So Google will have to go all the way to partnering with or acquiring a carrier who is currently an underdog and who needs this offering in order to win customers away from the big guys. Alternatively (and less likely, due to the red tape involved) Google will have to become or spin off that underdog carrier themselves as a new carrier.

So, look for the second shoe to drop: not who is going to build a “GooPhone”, but who is going to offer you a mobile plan that lets you use one without placing severe restrictions on what you can run on it.

Second, JRuby 1.1b1 has been released and as expected is considerably faster (see item #5 in this link) than the standard “MRI” runtime. JRuby joins Jython and Rhino in providing a JVM-based runtime for a dynamic language, with features designed to help developers mix and match the dynamic language code with Java code.

See the trend here? Python, Ruby, and JavaScript are emerging as the dynamic languages of the future for .NET and Java developers.

The hard work done by Sun and Microsoft to make their VMs work well is being leveraged by the next wave of languages. Threads, high performance I/O, memory management, and portability are all features that are quite expensive to get right, and the .NET and Java platforms have pretty much achieved that at this point. (Piggybacking newer, higher-level languages on these mature runtimes means that you get a mature new language runtime faster than if each language’s runtime were built from scratch and painstakingly debugged in isolation from the others.)

There are still some hurdles (performance, type safety fears, lack of mass market acceptance, ECMAScript 4 standardization and adoption, etc.), but in 2 or 3 years, things are going to change dramatically in the web application development world. The seeds of this change are already sown, and it’s just a matter of time. Threads, SQL, OOP, and garbage collection are all features of web application architectures that were initially controversial, but have now met with general acceptance. Dynamic languages are clearly the next step.

Obviously, Java and C# are far from dead, and in 10 years people will still be coding in Java and C#, because as with other languages like C and assembly, the newest and highest-level language isn’t automatically right for every project. But if you’re building web applications, most of what your code does falls into the categories of string manipulation, collection operations, or file and socket I/O. Image processing, crypto, full text search, and other CPU-heavy, byte-twiddling features may be part of your application, but you’re not writing the image scaler, RC4 cipher, or inverted index yourself; those are done in a library, probably written in C, and you’re just calling it. So your needs are likely to be similar to the sweet spot of dynamic languages: maximum expressivity and the fancy features to let you write clever code, making you productive and making the code as clean and elegant as possible. In other words, they put developer productivity first (lower labor cost and shorter development schedules) at the expense of runtime performance. Since hardware gets cheaper over time but code gets uglier over time, this is probably the right choice to make for most web application projects.

Another interesting benefit of layering instead of starting over is that the integration between dynamic languages and Java or CLR languages is much nicer than managed vs. unmanaged code in .NET or, even worse, JNI in Java. That is, it won’t be a bloody mess to mix and match code, from a technical feasibility standpoint. This matters, because The Big Rewrite is among the Things You Should Never Do. But little bitty rewrites are fine, especially if you have a thorough test suite to help you avoid breaking things. (By the way, dynamic languages are great for writing automated tests.)

Which of these three (JavaScript, Python, or Ruby) is going to be dominant 5 years from now? I don’t think any of them will be. The dynamic language community is fragmented, and the various vendors and big sponsors of these three languages are fairly entrenched already. Microsoft is investing in all three; Google has standardized on Python and JavaScript to the exclusion of Ruby; Sun has hired the JRuby team; Mozilla is heavily invested in JavaScript; Adobe supports JavaScript in AIR but not Ruby or Python, etc.

In fact, if you encapsulated the glue code sufficiently well, you could mix and match JavaScript, Python, and Ruby in your application, and port your hideous hydra between the JVM and .NET. You would be wasting a lot of effort since the three languages are largely similar, but you could do it. Alternatively, you could create a portability layer between the DLR and the JVM a la WxWindows, and write-once-debug-everywhere in a more productive language than Java.

These are all repugnant ideas, but only because as I write this and as you read this, we probably realize that to attempt this today would be a huge task. But what about in 2010? Probably not so gross. What about an application that could be executed on Silverlight, AIR, Firefox, SWT, and Mono, unmodified? How about a mobile app that runs on smartphones regardless of the runtime (.NET vs. J2SE)? Not gross at all, and not unthinkable if your app is written in JavaScript using some kind of portability layer that doesn’t exist yet.

In the longer term, JavaScript (a.k.a. ECMAScript 4) is likely to become extremely popular. As far as I know it’s not quite a perfect fit for Steve Yegge’s The Next Big Language, but it’s the closest thing there is, and it has two critical advantages over Ruby and Python that will make it successful: C-family syntax (which makes development tools cheaper to build) and effectively unanimous buy-in from vendors and developers.

So, what about the other dynamic languages that people are using in large numbers today? What’s going to happen to ActionScript, CFScript, PHP, and VB?

ActionScript and CFScript are pretty close to JavaScript by design; I’ve read that ActionScript 3 is actually compliant with the ECMAScript 4 draft specfication. It’s pretty clear that Adobe is betting on JavaScript. In the near future (2 or 3 years) I predict that Adobe will rev its products and support ECMAScript 4 across the board.

PHP and VB.NET/VBScript will hang around for a long time because they’re approachable and already very popular, but they’ve already peaked, and will steadily decline as developers switch to C# (on the .NET side) and Rails (on the Linux side), and then JavaScript as soon as a serious web app framework and an ISP-friendly runtime exist. Microsoft will keep investing in VB to keep customers happy; Yahoo will keep investing in PHP because it is so heavily invested in PHP already; new developers will find PHP to be an easy starting point for light duty web development, with tons of documentation and free applications that they can download and hack. But PHP will not inherit the kingdom from C# or Java, and the languages which do achieve mainstream success after C# and Java will do everything that PHP does language-wise, and the market momentum around those languages will make them better than PHP at what PHP does. Developers will ask themselves why they would write the client side and server side in two different languages, especially when the server-side language is more expressive and has better portability and libraries. That’s not true yet, but it will be in a couple of years. In 5 years or so PHP and VBScript will go the way of Perl CGIs: still used, but by a community a tenth of the size it is today.

What about the new Java-based dynamic language, Groovy? Groovy is interesting, but it’s too late. The Java mainstream of vendors and developers only recently managed to convince the world of “serious” C++ developers that automatic garbage collection and JIT compiled bytecodes can actually work in a high traffic context. The next battle, to promote the dynamic language features that Java lacks but which Groovy brings, will take years to fight. Once a developer makes a decision to not use standard Java, Groovy is on a more or less level playing field with the JVM-hosted versions of Python, JavaScript, and Ruby, but each of those languages has far greater adoption than Groovy, and each of them has greater opportunity for leverage on other runtimes than Groovy. For a Java developer, once the door is opened to other languages, the only advantage Groovy has is that its syntax is familiar. Compare this to JavaScript which web developers also need to know how to use; why learn a third language (Groovy) in addition to Java and JavaScript? Over time the simplicity of coding and debugging in JavaScript on client and server, together with dynamic-language productivity, will overcome the momentum of the Java standard, and web developers using server-side Java now will gradually replace it with JavaScript on the JVM. Conservative attitudes in the mainstream Java community (including Fortune 500 companies and the many offshore development firms that write code for them) will make this take quite a while – probably 5 years before JavaScript becomes a common part of the architectures that currently use J2EE, and 10 years before Java goes the way of COBOL (maintained forever but not used for new projects).

So in conclusion, keeping an eye on the future value of a technology, including who’s investing in it and who’s talking about investing in it, is critical to making your own investments today. In five years you’re not going to be using the same technology stack that you are today, and your project’s success and your own salary will be tied in large part to how well you invested today.

It doesn’t work like that, though, and our judgement is biased toward the things we already are familiar with. The stock we’re holding is undervalued, while the stock we want to buy is overhyped. The technology we’re using right now is obviously better than the technology we don’t know anything about. The stock will bounce back; we’ll sell it when it turns around and hits twice its current price. The new release with feature XYZ will make everything so much easier that we’ll be able to take Fridays off.

Concepts from financial investing that are helpful when thinking about technology more objectively are the Efficient Market Hypothesis, Fundamental Analysis, Market Capitalization, and Net Present Value. Each of these represents a structured way of thinking about the current opinion of the value of something in a manner that includes its potential future value and still gives you a single number to work with.

• Do you know something that most other people don’t know? Paul Graham says you can exploit this, in Beating the Averages says . EMH says you’re fooling yourself.
• Are you judging something based on hearsay? Fundamental Analysis is a tool for thinking about whether a stock is as good or bad as people say it is, and how that is likely to change in the future.
• Are you ignoring the behavior of others when making decisions for yourself? Market Capitalization is an aggregate of what everybody thinks, regardless of whether they’re right or wrong.
• Are you judging something based on its current value instead of where it will be, and how much it might cost you to get to a certain point in the future? Net Present Value is a tool for figuring out the value of future outcomes so you can decide whether it’s worthwhile to try to achieve them.

All of these concepts are just models for thinking about what’s really going on, and as such you should understand their shortcomings before using them. A major shortcoming is that your predictions are still going to be based on your subjective experience, and as such may be biased toward making you feel good about the choices you’ve already made. But they still hold lessons for techies trying to make choices about technology choices, for current projects or for improving your future employment options.

In Part 2 I’ll talk about why this is a timely topic.