What Software Crisis?

The Crisis
I hear the term software crisis from time to time, and it has always confused me. The software industry continues to produce and improve software at an astronomical rate. Users continue to consume it at the same rate. In addition, for all intents and purposes, this appears to be a totally sustainable trend. So where is the crisis?

As I understand it, those that use the term refer to the common occurrence of software projects not meeting time, cost or quality estimates. Certainly excessive time, cost or a lack of quality is a concern, but estimates and reality are not equivalent. However, other types of projects do not have the same difficulty in making accurate predications, so something must be wrong. Right?

I don’t think so. There is an alternative explanation to why software project estimates are so often wrong. It is not that the software industry is worse, but that it is better. No, this is not a tie-in to the worse-is-better philosophy. This relates to a fourth element in time, cost and quality matrix. It is called efficiency. In these terms, it is the rate at which cost and time are converted into quality.

This quality, efficiency, is the root cause for all of the unpredictability in software project estimates. The reason, is that efficiency among software development, varies greatly. This may initially seem a cause for concern, based upon the assumption that if some projects have high efficiency, and others do not, there must be something wrong with those that do not. The problem is that the differences in efficiency are not due to flaws in software project management, but due to an inherent difference in the value of quality.

For example, the difference between having the worst or best programmers has far more effect on efficiency than the difference between the worst and best in almost any other profession. Is there a much greater gap between the intelligence of the best and worst among programmers and other professions? I don’t think so. There may be a greater gap today than 10 or 20 years ago, but the effects of the “software crisis” was alive back then as well. In addition, 10 or 20 years ago, it would be easy to say that the gap between intelligence of the best and worst was less than most professions, since only very smart people were involved.

The Multiplier
No, the difference is not in the size of the gap, but in the importance of it. For example, if you took two people from another profession, where one person was 25% more efficient than the other, and retrained both as programmers, all other things being equal, I think you would find that the gap in efficiency would be far greater in the when acting as programmers. It might be something more alike to a 200% or 500% difference.

The actual multiplier also varies far more from task to task, then other industries. Coding a data entry form might have a relatively low multiplier when compared to debugging a resource leak in a distributed application.

Knowing this, we could try to decrease the variance by only using the “best”. But this is obviously impractical, since that is a limited resource, and the demand for software is far greater than is producible from that resource.

So how do we cope? My advice would be “just live with it”. Focus on raising the average efficiency, rather than attempting to standardize it. The only way to standardize efficiency is to bring the best down, and the effect of this would have a dramatic negative effect on average efficiency, and overall work output. This is not a suggestion to abandon all attempts to measure efficiency and predict results. These practices are still as valid as in any profession, perhaps even more so. The point is that we must accept that as long as the value multiplier remains high (and we want it to be) we will never be as successful at it as other industries.

Final Thoughts
One insight that we can gain from this realization is that for the time being, our focus should be upon measurement and prediction, rather than control. Control only becomes effective when you have sufficient quality information. If you exercise too much control without quality information, you are likely to do more harm than good. The process generally works as is, so until you know how to fix it.. don’t.

Another insight is that we should focus more upon developing efficiency through common sense methods. We should invest more in tools, benefits, and assisting developers, rather than cutting costs and restricting freedom.

Backwards Compatiblity of Operating Systems

It is well known, that one of the biggest challenges Microsoft faces in the development of operating system upgrades, like Vista, is the issue of backwards compatibility. While all application designers need to consider backwards compatibility, Windows more so than any other operating system, and almost all applications, is heavily weighed down by this concern. There is hope of an improvement to this, which I will get to, but first a bit of background into the difficulty.

Linux users are already predisposed to incompatibilities rising from forks, flavors and bundling, so backwards compatibility is easier to manage for developers. In addition, since the Linux community does not include many “basic” users, they leave the user to resolve many problems in this area. Being open-source helps too, by making it more possible for a user to resolve problems themselves. However, this assumes that either you are highly technical, or a highly technical user with the same problem shares a solution. In addition, in the area of hardware, having an open-source operating system may not help if you do not have sufficient information about the hardware itself.

Apple has an even easier time of it, for many reasons. First of these is the smaller number of applications for the platform, and the much more distinct clustering of user types. Apple users tend to come from a much less diverse group, and thus rely upon a much less diverse set of applications.

Another factor in their favor is complete control of the hardware platform, which limits hardware compatibility issues. I would list this as the primary advantage, except that hardware concerns tend to be shorter lived and self-resolving. For example, some companies still run 16-bit Windows code, more than 10 years old, but how many run 10 year old hardware? Even the most miserly IT department ditches PC’s within 7 years. Even more importantly, the capacity limitations of such machines are an irresolvable impediment that users generally have some acceptance of, so when gathering driver support 5 years is acceptable, except for some peripherals like printers.

Even here, Apple has an advantage in that its users are more willing to pay large amounts for expensive hardware and upgrades. Most Apple users do not upgrade as often as the die-hard PC gaming community, but as an average, it is more often, and the upgrade tends to be to a near top-end system they will use for 3-5 years before disposing of. Lastly, you will not find many Apple users attempting to string along a system with processor upgrades and such.

Microsoft on the other hand has many corporate users, who still run 16bit Windows or even DOS applications, and they demand, in a rather loud manner, that these new versions of the operating system support these applications. A recent article on the 64-bit version of Vista, makes a good point about how the 64-bit version will be abandoning many of this baggage. It is an interesting strategy and might just work. The 32-bit version should keep those troublesome corporate customers happy, while the 64-bit version creates a clear imperative for software and device manufacturers to ditch the incompatible elements.

However, it may be far more difficult than this because the hardest and most important part is convincing corporate IT departments to ditch those old apps. Not being able to run the 64-bit version, and loosing out on its higher end security will have some effect, but it may be more of a low buzz, rather than the loud fire-alarm effect it takes to create action for many stubborn administrators and users holding on to outdated applications.

If they do not we might see a divergence of consumer and corporate versions of Windows, similar to the Windows 98/2000 split. What is interesting is this time the roles will be reversed. In addition, notice I do not mention NT 4.0, which very few adopted as a workstation. Like 2000, it targeted corporate users, but generally failed to gain traction because of lack of backwards compatibility. 2000 was still not as compatible as 98, but was far more than NT 4.0. By the time XP was released, many corporate customers were firmly entrenched in 2000, and many have never upgraded to XP as a result, despite one of its primary features being even greater backwards compatibility with Windows 98 and DOS applications.

One lesson of all this is it is very difficult to predict what compromises users will make in the area of backwards compatibility. Some will follow one path, others another and the question of how to reunite all under a single banner can be a difficult one. The battle against requirements of backwards compatibility is one of the several disadvantages of being the dominant operating system. It is not specific to Windows either; any operating system in a similar market position would have similar difficulties. Closing your system, as Apple has done, can make it easier, but that is an unacceptable condition for a dominant operating system.

What is a software architect?

What is a software architect? This can be a confusing question, for plenty of reasons. One complication is that architects often operate in environments where they do not have the proper authority. Architects in these environments will then understandably tend to focus on the problems over which they have some direct control. As they continue to do this, the commonplace definition of an architect changes, such that you will find architects who begin to believe their role is entirely isolated to the abstract.

The truth however is that while an architect must produce an abstract system design, they must also have a role in the events that occur both before and after this design. Before the design, an architect needs to be involved in requirements selection. I rarely see this occur, but it is incredibly important.

Since an architect’s primary role is to develop the abstract system design, they are in the best position to quickly assess the feasibility of any requirement. Even more importantly, the architect is in the best position to observe the synergistic or conflicting technical nature of multiple requirements. If two requirements both require building the same underlying subsystem, then the cost of developing both is less than the sum of the cost of developing both separately.

After, production of the abstract system design, an architect needs to be directly involved in the realization of those designs through several means. The most basic is through continued guidance in technical implementation and refinement of the abstract system design. An architect should be prepared to field questions from developers, and assist in decision-making, when asked to do so.

An architect also in my opinion should be involved in the development of the architecture. To me, the architecture is not the abstract system design, but the expression of that design. It is not as big as the entire system, but it is an integral and inseparable part of it. Much as all buildings have an architecture, so does every application even if not formally designed. It is however ordinary to call the architecture design, “the architecture”.

Therefore, when I say the architect should be involved in the development of the architecture, I mean he should actually create some of the code for it. Unlike every other activity of an architect, the purpose of coding, as an architect, is not to support the developers, but to support the design. Interacting with your design by implementing and utilizing it will always provide useful feedback.

I often see the argument that building architects do not build buildings used to refute this statement. I have three issues with this argument. One is that while a skyscraper architect may not ever build even part of a skyscraper, I think you would find almost all architects have physically built things of a smaller scale. The process of building, even at a smaller scale gives the architect an insight into the actual process of building.

The second issue is that a building architect will usually inspect a building as it is being constructed, and again afterwards. This process provides valuable feedback which when combined with experience with building smaller objects, comes close to the experience of actual participation.

The third issue is the demands and principles of building architecture are far more stable than software architecture. Thus for a building architect, experience with other projects is more lasting, and feedback from the current project while critical, is less so.

So yes, in the software world it is possible for an architect to get similar experience by coding outside the scope of the project, and by inspecting the system. There are however complications to this approach.

Because the underlying demands and principles change more often, it is necessary to insure that coding endeavors are relevant to the current project. Proofs of concept projects are one method to do this outside of a project, but working within the project will do an even better job of ensuring relevance, so long as the architect focuses on architecturally significant parts of the project, and not minutiae.

In addition, while it is possible to inspect the system code, this is a large part of the overall investment in coding, leaving little gain from not participating.

Another role of an architect is the resolution of technical conflicts that arise between two developers, between developers and requirements, and between developers and design. This is where the issue of authority comes into play, and is an area I have found to be lacking. Except for the area of conflicts between development and requirements, the architect is the individual in the best position to weigh all the trade-offs. When requirements are involved, architects still have a key role, in assessing overall technical impacts.

For conflicts between two developers or a developer and design, the architect ought to have authority. Roles in the best position to weigh trade-offs and choose the best option should be the roles with authority in any given situation. Authority naturally leads to responsibility. Responsibility could be defined as the person you blame, but it really should be the person who exercised authority. It is also important to note the difference between having authority and exercising authority. Choosing not to act is itself exercising authority, by denying it to others, but it is fully possible to be denied the opportunity to exercise authority, while legitimately having a right to.

Somewhat related is the difference of governance and authority. While partially synonymous, governance and authority have different connotations. Governance can be the act of exercising control, and generally implies this, whereas authority is the right to. Since control is such an important topic, these small differences can have surprisingly large impacts. Governance efforts usually attempt to uniformly and consistently exercise control, even when unnecessary. It is much more common to find that individuals or organizations granted authority, exercise that authority much more judiciously.

Architects should strive for this. With a good initial design and a good development team, conflicts that require an architect to exercise authority, should be uncommon. Over application of authority will devalue the efforts of others without positive effect.

As well, application of authority based upon insufficiently complete information will lead to poor decisions. However, when conflicts occur decisions are required, preferably quickly. When data is less complete, the data should be a guide, or tool, rather than the deciding factor. Strict governance based upon strict rules will rarely exceed the performance of heuristic evaluation unless a very complete and descriptive set of data and rules exist. Attempting to lock-in the result of rule-based analysis prematurely is a formula for disaster. The results of rule-based analysis however can provide great benefit in the form of suggestions, if lock-in is avoided, even when data is of low quality. Since as a general rule we are very far from complete measurement, I prefer to avoid strict governance.

So to sum up, for me an architect is an individual who creates and maintains the abstract system design. An architect also must provide guidance based upon that design, both before fully detailing it, and after. Lastly, when conflicts arise that are subjective only to the constraints of the system design, it should be the architect who has the authority to give resolution.

FlexGo and thoughts

Apparently, Microsoft has a plan to more or less rent PC’s in emerging markets. The program is called FlexGo, and when I first heard of it I did not think much of the idea. It still does not interest me personally, but after I read an article that explained their target market the idea made a bit more sense.

The target market is users who are currently paying money at an Internet Café. Thinking of it this way, the Microsoft plan might actually save these users money while being more convenient. In the long-term I think the plan is doomed, but long-term is more like 10 years, which gives plenty of time to build markets and make a little money too.

Though, with the prices I have heard mentioned I have to wonder if they will make money off it. They may have to ask the Gates foundation for support to make it work, which would not really be a horrible thing.

I think the world could benefit a lot from more business based charity. Traditional charity efforts have generally seemed wasteful to me, because they are so easily taken advantage of both by executives, vendors, corrupt governments or often the people they are trying to help. I think you would see a lot less of this in endeavors that run half as business. In a way, this is similar to my idea about open-source.

There is a lot to be said for the power of money, and not all of it is bad. If we can find better ways to use that power for good, we would all be a bit better off. What this requires though is compromises, and corporations are in general no more apt to make any significant compromise than idealistic charities. Kudos to those that do.

Phantom Applications

Wow, weird. I just uninstalled the Office 2007 beta 1. I somehow forgot to close Word before I did this however, and was very surprised to find out that the uninstall went perfectly without even closing Word. All the files are gone, everything is running fine, and Word was still responding to clicks, even offering to save the document.

How does that work?

The Maps, The Clients

Ran into some interesting map information tonight and it made me look at the different mapping tools out there right now. I actually started with Windows Live Local, which looks to have made some nice progress. The traffic and construction feature is my favorite improvement. I am not sure what areas are covered, Chicago is fully covered, and Columbus (my old hometown) only had construction, but not traffic.

They also have a new “bird’s eye” feature that shows some amazingly detailed zoom ins, but coverage of that is fairly limited at this time.

After seeing that, I realized I had not actually used Google for a bit, so I tried Google maps. As far as I can tell Google maps has not really changed at all for quite some time. It felt a bit faster, but otherwise unchanged.

Personally, I have always favored the rich client map programs over the AJAX apps, so I tried Google Earth next. The difference between Google Earth and Google Maps is extreme in terms of functionality. Not only is the speed difference incomparable, I also have access to so much more information in Google Earth. I went out and quickly found there a site with a Chicago traffic KML. It did not work quite as well as the Live Local traffic, since it did not cover as large an area, and did not have the construction information. The KML and Live Local both use traffic.com by the way. There might be a better, more complete KML out there, but I did not spend the time to find it.

Of course in Google Earth I had all the other Chicago KML’s I have downloaded before, like one that tracks weather, and one that shows close to real-time position for all flights into the local airports. For getting live information, Google Earth is unrivaled. I somewhat wonder why Microsoft has not yet adapted MapPoint (the CD based version) to have a rich client free version, much like Google Earth rather than spending so much on Live Local.

MapPoint is my tool of choice when traveling since I do not need an Internet connection. Unfortunately, I doubt the price of the CD version is something most people are willing to pay. I only have it because it’s part of the MSDN subscription. It is an awesome tool however, with quite a few advantages over Google Earth, but unfortunately without Google Earths online extensibility. I know a new version (2006) was released recently which I have not yet had the chance to try, but I have not been lead to believe it is anything other than updated maps. I will probably get it installed here in a few days since I will be traveling again in a few weeks, so I will see then what has changed.

There is another point to this post than comparing these tools. Notice, the great tools are not the AJAX tools that get so much press, but the rich client applications. AJAX is not the user experience savior it is made out to be. It is a major improvement over what web applications did before, but it is like moving from the Stone Age to the Bronze Age, while rich client applications are more like Rome. Everyone will tell you “the barbarians are at the gate” but is that really true? I think rich client applications can be designed do everything that a web application can, and except for basic things like a storefront, developer effort will come out as a net-win for the rich client application, while producing a better user experience.

Thoughts?

Part of why the IPod is doomed

As this list should show, the iPod simply has too much, and too diverse of competition to be able to cover ever users wants/needs. My personal favorite, which I'll probably buy rather soon is the Sandisk e270. Basically as light, and almost as small as the Nano, it has a 6GB plus a SD slot for expansion. Right now these max out at 1GB, but they'll probably grow to 4GB before you decide to buy another player. Adding to the longevity is the fact that the battery is replaceable, which is an uncommon feature for MP3 players (and not something any iPod I know of does).

Yahoo Music is better than iTunes, especially the almost unique Launchcast Plus service (there is also Pandora, which was created by the designer of Launchcast). iTunes has nothing like that last I checked. Also, your not locked into only a purchase plan but can do a subscription as well (it is your choice).

So what is Apple best at? Oh yah, locking your hardware and software up into a inflexible system, giving you no options for buying, browsing, listening to music except for their limited choice of hardware, and their inferior software.

Opening up DRM.. Kinda.. Maybe

I do not completely understand how this company Navio’s software works, but the basics sound like a good idea. The basics of it seem to be that they have a way to sell licenses to DRM content without selling the content directly. This supposedly means they can sell licenses for WMA, Fairplay or OMA, or better yet, allow delivery of all three licenses in a single package.

Like I said, I do not really understand how it all works yet, but an even bigger question is if they can sell Fairplay licenses without being sued. Either way however, it is a good step forward for users in general by in theory unbundling your rights from any specific technology, WMA included. WMA may be a lot better than Fairplay in terms of being fair and open, but going one level above that would be a good thing, because once you get to this level, the technology is decoupled from the sale. I would be a bit more thrilled if Navio was licensing their technology, rather than setting up storefronts, but if they can do it, I suppose anyone else can too, right?

I first heard about this from this CNN article. If anyone has a better idea of how this stuff works, let me know.

The opposing viewpoint

I am a very opinionated person, but also consider myself very independent. Sometimes I feel the need to do a double take, and really look at the other side of things. It is a tough thing to do, especially when the other side is full of zealots. The problem is that even though 90% of what they say is unsubstantiated rhetoric, there are usually a few valuable pieces of information hidden within.

In addition, we all have a somewhat natural tendency to try to gather in groups with like-minded people. In some cases, this can be a good thing. For example, if you are trying to build something, or design something, it is a very difficult thing to do if no one agrees upon the basic principles. But in many other cases, it can be very damaging. On very heated issues, when groups separate into two groups, overtime they often diverge further and further, until both sides are wrong. I’m not going to try and offer up any specific examples, because that’s not what this post is about, and any good example of this would quite obviously draw a lot of criticism on whatever my viewpoint was, or if I failed to offer my viewpoint, criticism from both sides.

And that itself is perhaps the biggest problem in polarized issues. At some point the zealots of both sides start to be uncomfortable not only with the other side, but with the people who are semi-neutral. It is not that neutrality is somehow superior to strong opinions, it is that being invested in any point of view, including neutrality itself, is a bad thing. A good mind is an open mind. This does not mean you should not have opinions, but that your current opinions should not be what shapes your future opinions.

Once you begin down the path of polarizing yourself, you start to loose the ability to think rationally, and even if your out to prove a point, because you feel that point is very important, an inability to think rationally can only harm your goals. Even worse is you may eventually find you have stepped over a line in which you are now as great a problem as the one you initially set out to resolve.

One of the best preventive measures is to force yourself to listen to the opposing viewpoint, no matter how ridiculous it may sound to you initially. While you are listening, pick it apart in your mind, rather than trying to throw back witty retorts. If you immediately begin with retorts, the conversation will quickly devolve and you will never see beneath the surface of the argument. This surface may be divorced from reality, but if you listen long enough, you should be able to spot where this happened, where an initially rational objection was replaced by dogma.

This admittedly can be a very difficult thing to do. You will be tempted to react, afraid that if you don’t you’ll be viewed as actually accepting the viewpoint. Not wanting to increase the confidence of the opposition, you will feel an immediate need to attempt a conversion. There is a time for debate, and a time for research, and you should view this as research.

One great thing about the Internet, and bloging is that it is relatively easy to expose yourself to some of these opposing viewpoints without having to get caught up in the whole system and community of the true radicals. Even this can be frustrating, as you may have to dig through a lot of repetition of unfounded, non-rational writing, but if you try hard enough you can find valuable ideas you never would have if you had stayed within the confines of those like minded to yourself. Maybe you will find you are at least a little wrong, maybe you will find the reason for the opposing viewpoint (Hint: It rarely is that the other side is evil, criminally insane, or functionally braindead). Or, possibly best of all, maybe you’ll find a compromise that is better than either radical viewpoint.

Blue Security should be a rallying point, not an appeasement

Earlier this week, Blue Security shut down operations in response to several attacks by spammers. While I can understand CEO Eran Reshef’s point of view, and cannot ask him to take the brunt of such attacks, I totally disagree with the opinion that it was the right thing to do. What happened was nothing short of electronic terrorism, and we should all know that negotiating with terrorist is almost never the right choice. In my honest opinion, the only reason ever to negotiate with a terrorist is when you fully intend to double cross them, and use their own egos to further their capture and downfall. Who cares if you are lying to them? They are basically evil, so why worry about that?

The right thing to do, in my honest opinion, is to use this as an opportunity to find, prosecute, and punish anyone audacious enough to carry out an attack of that scale. People like that are dangerous, and they will not get better with time. During the process of carrying out an attack like that, a cracker exposes a great deal of his resources. At the very least, you have the opportunity to find and neutralize the zombie networks so that future attacks are more difficult. Even if you do not have sufficient information to trace the original cracker, attacking his resources will require him to take more risky efforts to rebuild them, which with persistence will lead to their downfall.

I can only hope that Blue’s decision is a sign of intent to regroup and prepare to fight back, but unfortunately, nothing I see indicates this to be true. It is not acceptable to appease evildoers like spammers for short-term security, because ultimately you are drastically compromising long-term security. Over time, the demands of crackers like “Pharmamaster” will only escalate as they see success and continue to build their offensive and defensive capabilities.

In a sense, this is much like warfare, and as any good strategist will tell you, you can neither rely upon offense nor defense entirely, but must use both. Blue Security was a strong offensive capability, but they failed to invest sufficiently in defense. Despite that, spammers have no method to annihilate Blue Security unless we cave to their demands. Any DOS attack is temporary, but the arrest and imprisonment of a cracker is a relatively permanent success. Besides getting the cracker out of the system, and neutralizing his assets, you also send a clear message to other aspiring replacements. Unfortunately, shutting down Blue Frog is exactly the message we do not want to send.

Now as I said earlier, I cannot fault Eran Reshef for his decision, because ultimately, he has no obligation to bear the brunt of a issue much larger than his company, but I would like to see our government take the issue seriously and extend assistance to Blue Security, and to companies like them that are subject to such attacks.

Policing Microsoft – The Good, the Bad and the Ugly

We can all agree Microsoft has an almost complete monopoly on operating systems. We can all agree that monopolies are a dangerous thing, and at the least require supervision.

Where agreement breaks down is in what to do about it. It is very annoying to read posts at major sites like Slashdot on the subject because even with the post scoring system, any good idea is drowned out in the endless meaningless dribble fueled by nothing more than mob mentality. It’s not that there aren’t any good ideas. The problem is there are so many bad ones, and it seems like almost no one bothers to check for the difference.

Some of the good ones? Well I think pushing Microsoft to do better documentation is certainly worthwhile. To be honest I think these days Microsoft has some of the best documentation out there, but I will never complain about more, better and quicker. Nevertheless, do us all a favor and admit that documentation is not the easiest task, and never use it to block the release of innovation. If the EU or DOJ doesn’t believe Microsoft is trying hard enough at documentation, hire a raft of consultants, send them to Microsoft, and send Microsoft the bill if they manage to do a better job.

On a tangent however, regulatory agencies might want to consider applying this idea a bit more broadly than just Microsoft.

Another good one is regulation of contract law. What I think is more effective, and sensible, than simply threatening huge fines for negotiating a bad contract, is to make it clear you will not uphold any such contracts. Overall, I think the government has achieved their goals here. Manufacturers don’t seem to be worried about selling other operating systems (www.dell.com/linux/), but some are still afraid of selling AMD processors.

There are plenty of bad ideas out there too. For example, the whole bundling issue is totally wack. The proof of why this is such a bad idea, is total inconsistency of proponents. I have seen far too many anti-Microsoft posts that first rail about the bundling of Internet Explorer, and then later criticize Microsoft for not including anti-virus with the operating system.

This inconsistency demonstrates clearly that there is a real user demand for bundled products, whether they admit it or not. Another clear demonstration is that other vendors bundle products even more aggressively than Microsoft, and their users love them for it. Now, if for example, Microsoft didn’t allow you to install a competing browser, the case would be far different, but that is not the case.

The number of double standards on this issue alone is astounding, and I do truly believe it is harming Microsoft and users of Microsoft software. Microsoft has been following a bit of a me-too strategy in all of the free-software areas, and I think this is not just due to typical corporate bureaucracy, but also with the fear that any new service that isn’t me-too will draw even greater attacks.

Then we come to the ugly. The worst idea is that Apple should replace Microsoft. In terms of being open, Apple makes Microsoft look like a saint. Actually, Microsoft historically has built their business to a large degree on openness. The open PC hardware platform was the first part of this, followed by the wide availability of the Win32 API, which created the huge software base upon which the operating systems current dominance is built.

Also, in many ways .NET is more open than Java. The ECMA specification of .NET is and licensing of such is a fair bit more open than Sun’s process, which reserves rights to all final decisions to Sun alone (this is actually the clause that Sun used to revoke Microsoft’s Java license).

Nevertheless, no matter whether you think Microsoft does good, poorly or atrocious at being open, it is very hard to deny that Apple is in an entire different category of behavior, many levels lower.

I can see the draw people have toward a free operating system however, but Linux, and open-source software in general still has some hurdles before it can prove to me that its really what is best for all users. On one front is the user interfaces, and ease of configuration, which I fear will always be a problem with a tool like Linux that is designed to please its designers, rather than its users. There is also a big question of whether the somewhat rosy world of cooperation that exists today might evaporate if the community’s arch-nemesis was defeated. Lastly, I think the open-source community should accept that they are supporting commercial software development today, and embrace all types of user, whether they are “benevolent” consulting companies, or they are commercial software vendors. It should not be necessary to jump through artificial hoops to make money off software.

I am sure there are quite a few more from all three categories, but from here on out I will try to focus on the good. Maybe if more of the anti-Microsoft camp out there did this, they would find ways to not only encourage innovation outside Microsoft, but within as well. But so far, most seem to be complacently happy with the concept that the best thing would be to destroy Microsoft at all cost.

Ruby.. BOO! CLR LISP JavaSchools.. and a total lack of focus

I finished the Ruby book I was reading online, but unfortunately, it ended before the continuations, so it looks like I will need to find another resource to finish up. I suppose I could start writing a program, but I would rather keep digging. If anyone has a good recommendation for an advanced Ruby resource (and by advanced I mean high end features, not written in gibberish), send it on.

So instead of following up on Ruby, I instead started looking at Boo. Someone suggested it and I have to admit, I am impressed. I do not care for some of the syntax, but I really like the type inference system, which goes a bit farther than var in C# 3.0. I do however wonder if making inference the default, instead of explicit through var is the right thing to do, but I’m not really sure one way or the other yet.

As far as syntax goes, one thing I do not understand is def. Why is that there? However, ignoring some oddities like this, it is a beautiful achievement. Beyond the language itself, the site is really interesting because of how well it demonstrates the not well know cross platform capabilities of .NET. See.

I knew about Mono before, but I had never heard of GTK# before. Boo has an Eclipse plug-in as well. Oddly, there is no VS.NET plug-in for boo. The whole project is an interesting mash-up of many different technologies that people generally assume do not fit together.

Boo also has some cool language features.

On a related note, I also read a set of articles that I found interesting. Sriram seems to be in the same mode as I am, trying to soak up the juice from languages like LISP. I would totally agree that I have failed to fall in love with LISP, or even Ruby. There are some cool things there, but I am driven away by others. LISP is far worse in this way. Despite that, I am still very happy that I spent the time on it. I may never write a single line of LISP code, but that was not the point was it?

Sriram, pointed to an article on teaching Computer Science. While Joel may be right that his tried and true tests do not work as well on someone who has not studied LISP or something similar, I wonder if he is not making the same mistake he criticizes others for. That is that he is using “grep” to evaluate resumes. He is looking for LISP experience however instead of Java experience. What he should really be looking for is a way to test his candidates that does not rely upon prior knowledge that is unrelated to the job.

Joel compares the ability of developers to grapple with recursion and pointers with the ability to create architecture, because they require a similar skill of breaking down problems to properly solve. However, why not use a test that only requires that skill, but only requires commonplace knowledge. Even better might be to actually test their ability to create architecture, but I suppose Joel feels that either this would take too long, or that he does not expect his candidates to come to the job with that knowledge.

However, if what you are looking for is problem solving skills and architecture knowledge, why look for LISP knowledge, or pointer knowledge, etc. which may never come up for the average developer?

Toolbar not Searchbar

Both Google and Microsoft stopped calling them search bars a long time ago, but both toolbars still don’t let you remove the search box, which I’m finding to be a real annoyance. For one, with IE7 the search box (or FireFox) is pretty redundant, but it’s even more redundant if you like a feature from Windows Live toolbar, and one from Google toolbar. In most other aspects, both toolbars are pretty good about letting you disable such and such. For example, you can get rid of the auto-fills, popup blockers and other redundant junk.

However, the best you can do with those search boxes is try and make them as small as possible. It is a quandary for me because I still like the Desktop Search feature from Microsoft a lot better than the Google equivalent, but since I do searches with Google I prefer Google bookmarks to Live Favorites.

For those wondering, what I like about MS Desktop Search is the way it displays results, which offers a lot more flexibility than Google’s somewhat plain web-style. That style may be good for websites, but it is not nearly effective when working with my own files. With web-searches you are likely to pick one or three of the top results and that’s it, but when I’m searching through rafts of source code, documents, or such I’ll want to be able to sort by time/name/location, and scroll through the list easily, which the web-style does not make very easy with the multi-page style.

Actually, on the note of desktop search, can we get that into the IE7 search box? It is surprising Microsoft didn’t already do that, but I wouldn’t be surprised that it has something to do with feeling the need to make sure that Google desktop search can be added, and that it’s not just Live desktop search. Because if they didn’t Google would throwing even more of a fit than they already are.

So, while you two are at it, make it so the search box contents can be used to highlight terms on a page, the way the toolbars do.

Yipee!! Bittorrent will have legal downloads.

Quite a few years over due in my honest opinion. Only about everyone and their grandmother has suggested this by now, but finally one studio has stepped up and realized their error in not using technology like Bitttorrent. Details are somewhat slim so far, but it looks hopeful.

Static/Dynamic? Why not both?

So.. it's been quiet here. I decided, a bit more than a week ago to learn LISP. I have been hearing things about LISP every so often, how great it was, so I got this feeling that I should give it a look. Somehow, in the middle of this project I decided to study Ruby as well. To add to all this I'm trying to compare both of them to C# 3.0.

It's been an interesting journey (which is not done yet). Both languages are of the dynamic variety, which I have a personal bent against. I see the value of dynamic typing for some situations, and it certainly made a number of interesting features of both languages easier.

For example, dynamic typing is very useful for interpreters (like IRB or REPL), and it is easier to include metaprogramming, or LISP style macro capabilities in a dynamic language.

On the other hand, static typing has immense benefits too. The obvious one is the ability of the compiler to protect you from yourself. Most dynamic typing advocates tend to dismiss this as the argument of a "newbie", but the truth is that it is not as simple even as protecting you from yourself, but perhaps protecting you from your neighbor, etc.

It is naive to assume that experienced developers don't make mistakes. In fact, the most experienced developers probably make more mistakes than average because unless they are lazy they are working on harder problems.

But.. I am starting to rehash a common debate, which is totally unnecessary. It is unnecessary because I don't believe that dynamic and static typing are wholly incompatible. Maybe if the two camps would bury the hatchet we'd see better alternatives.

Dynamic languages for example, can easily include psuedo-static typing, and quite a few do to a very limited degree. But why is it so limited? Take LISP as an example. LISP includes support for declaration of types, but it is very rarely used, except for performance gains. I could be wrong here, but I think the main reason is LISP implementations never included type checking. Most dynamic languages actually tend to eschew the concept of compilation entirely.

I think it is great to be able to quickly test your code in an interpreter (or JIT as is the general case), but why aren’t there systems to check your code when preparing a release? Actually, preparing a release is too late. Really, it should be like Visual Studio, where it is checking your code as you write it, but I see how this might be a bit difficult, so I would settle for having basic code validation tools.

However, good validation tools require support from within the language, and from the developers. It is obvious that with runtime metaprogramming you can break things a validation tool would think was ok, or vice versa, so languages would need a way for you to suppress validation on specific sections, or the false positives could be a big problem.

On the static side, I actually see the trend developing already. C# 3.0 (and C# 2.0) are excellent examples of how static languages are working to bring features traditionally associated with dynamic languages to the static world. C# 3.0 also introduces some pseudo-dynamic capabilities. “var” is an example of this. Technically everything is still static, but it does not always feel that way, and when combined with anonymous types, methods, and lambdas it does more than just feel different.

There is still plenty left to do here though. I think it might be very interesting to introduce an almost totally dynamic option to C#. I was thinking of the ability to take a try/catch block and append mode options to the try. For example:

try runtime
{
  x.IHopeThisMethodExists();
} catch (RuntimeCompileException e)

Of course code like above would be treated with about the same level of regard as unsafe {} but it could be very useful for testing some changes quickly, or for building mini-languages into applications.

Duck typing is another option, approachable from either side. Dynamic languages can do some duck-type code validation, and static languages can use it as well with the proper restrictions. I static language should have little difficulty in generating “anonymous” interfaces at compile time if that is how the developer designs things. You could just as well reuse the try runtime metaphor as try ducktime… or maybe something a little less silly.

Anyhow, that is about my limit for the night.

Achieving Escape Velocity On Conservation

Maybe some good can come of all the flustering and blustering over high gas prices. Congress is coming up with some really dumb ideas, but it is obvious they are concerned, and starting to think of things they would have considered political suicide not too long ago.

Maybe the rest of the country is the same as well. I hope so. If we're lucky when gas prices come back down (assuming they do), a culture shift will have occurred. It's interesting how one dramatic event can spur that kind of change. I am a bit afraid that $3.50 isn't dramatic enough, but possibly it is?

What price does it take to instill a long lasting fear of the next price hike in potential guzzlers? I think something of that nature might be healthy. That fear could make them rethink that new AWD Vortec V8 Yukon (12mpg). Maybe they'd buy a hybrid SUV, or a smaller SUV.. or maybe they'd even buy a car.

Also, maybe Congress will have a similar effect. Congress has a pretty short memory, but if some of those frightened consumers keep the pressure on they may actually react.

There are good signs already, but they could just be temporary reactions. One example is that in April, gas consumption actually fell for once. Only half a percent, but that was only one month too.

Or look at this http://money.cnn.com/2006/05/04/news/economy/oil_bill.reut/index.htm.

Or even better: http://money.cnn.com/2006/05/02/news/economy/exxon_ceo/index.htm

Search Providers and Choice

A number of people have pointed out Google's double standard on search defaults, but there is big one I haven't seen so far.

The Google Toolbar. You can't customize the search provider for it, can you? The MSN\Windows Live Toolbars allow you to customize your search provider. In fact I've been using it this way ever since I switched from the Google Toolbar (I liked the way that MSN Desktop Search displays results alot better.. but that's another topic). But the Google Toolbar (and probably Yahoo, etc.) doesn't.

Several people have pointed out that IE7 doesn't change the setting, it just reuses it. And this I can confirm as well, as when I started up IE7 Google was the only search provider listed. Microsoft didn't even add themselves as an default second option, which they could have.

But here is another interesting point about that. The Google toolbar "offers" to change your default IE setting when you install it, so most all the IE users who have installed it will end up defaulting to Google when they install IE7. What I mean by "offers" by the way is one of those default on settings in a window that the average user is likely to just hit next... Much like the ones in Acrobat installs that tries to sneak the Google toolbar in, and other stuff.

With all of this, I half wonder if more users will default to MSN than Google.

Google.. I love ya but I think you have a bit of a climb before you can take the high ground on this one.

A bit less practical of an idea.

Ok, nothing revolutionary, but I found this CNN article kind of funny when compared to my idea on how to bridge the comfort gap between cars and public transportation.

Now I think my idea is generally a long shot in the short term, but somehow I think it has a little bit better chance of success this writer's idea ;p