First of all, I chose to have my software released under an open source license because I want my code to be available for others to use if desired and also to waive the liability from any damage which could occur. With the choice to open source the software, there are many open source licenses to choose from. Of all licenses, the most famous is probably the GNU General Public License, or the GPL.

The GPL tries to keep the software free. However, this is puts restrictions to how the software and its source can be used. For example, if I release my software under GPL, people who want to incorporate my code into their software can do so without restrictions. However, if the person wants to release the software that uses my code, they must also distribute their code under the GPL. To me, this is a restriction that I am not particularly enthusiastic about. This leads to some debate whether or not the GPL can be considered viral.

Don’t get me wrong, I don’t have a problem with GPL. In fact, I use many GPL’ed software like OpenOffice.org, the GIMP, VirtualDub, to name a few. However, I would like my code to be used without restriction of having to release the source under GPL. The requirement that GPL’ed code can only be used in a GPL’ed program seems a little bit restrictive, and that requirement seems to promote the proliferation of GPL-licensed software over the freedom of using the software itself. A non-copyleft license like the modified BSD license seems to be less restrictive in the sense that it allows the people that obtain the software to do what they want to do with the software. The “Types of copyleft and relation to other licenses” in the Copyleft article at Wikipedia sums up the issue of freedom:

This debate hinges on complex issues such as the definition of freedom and whose freedoms are more important, or whether to maximize the freedom of all potential future recipients of a work (freedom from the creation of proprietary software). Non-copyleft free software licenses maximize the freedom of the initial recipient (freedom to create proprietary software).

The GPL is concerned about having software free from being locked up in proprietary code, while the BSD license is more concerned about giving freedom to the person who obtains the software to do anything they want to do with it.

Although most the software I’ve released so far use the modified BSD license, it doesn’t preclude me from picking the GPL as the license of choice for a piece of software if I feel it’s better suited than using another license.

The following are some screenshots of coobird.net before changes were made to make the page rendering more consistent between IE6 and other browsers:

Firefox 2

Opera 9

Internet Explorer 6

Searching around for the CSS font rendering of Internet Explorer 6, there are quite a few people out there who are experiencing the same problem. One way to fix this problem is to use a different style sheet for Internet Explorer 6 using conditional comments. (Hack-free CSS for IE was a good article on conditional comments.)

Currently, coobird.net implements the conditional comments technique mentioned above to use a separate style sheet that specifies different font sizes and border thicknesses for IE6. Finally coobird.net looks half-way decent on Internet Explorer 6.

For the past few years, I’ve been using the OpenOffice.org application suite on my PC. During my high school years, I recall using Microsoft Works, which was adequate for my school work. When I read about OpenOffice.org back around 2002, I went ahead and downloaded it and have been sticking to it ever since.

Why do I insist in using OpenOffice.org? First and foremost, Microsoft Office costs money. This was the primary factor that lead me to choose OpenOffice.org over Microsoft Office. Being a college freshman without a job, I couldn’t afford to go spend hundreds of dollars on an application suite. I’m more than aware that I don’t need to look far to find a pirated copy of Office, like many people I know, but I would rather not go that route. Fast forward a few years, now I could afford to buy Office, but I would rather not spend it when I have an acceptable alternative like OpenOffice.org.

The main gripe I’ve had lately with Microsoft Office is its pricing. I’m aware that the Home and Student edition of Office is available in the neighborhood of $150, but that is still a little bit steep for a piece of software that I don’t really actually want. However, if Word and Excel were available for $30 a piece, I would probably be willing to shell out the cash to avoid dealing with the annoyances of incompatibilities in importing and exporting Office documents. (Those incompatibilities of course stem from the fact that Microsoft keeps its file formats a close secret, preventing interoperability with other applications. Don’t get me started on this one!)

OpenOffice.org has been my office application suite for the past few years. I’ve written countless reports on it and haven’t had much problem except for some lack of features in the spreadsheet application. The cost of Microsoft Office isn’t as a big issue as the past, but I’m not very willing to spend a large amount of money on a piece of software that I don’t actually want to use in the first place. That’s what keeps me an OpenOffice.org user.

A buffer overflow is one of the ways to allow remote code executions to occur. In a nutshell, a buffer overflow occurs when program allocates some space in memory to store data, but the amount of data received is larger than the allocated memory, causing an “overflow” of data onto other parts of the memory, which may end up being a portion that the operating system has marked for executable data.

When programs are properly written, buffer overflows shouldn’t happen. The program should be validating the incoming data and only accept enough data that it won’t cause a buffer overflow. However, it’s easy to overlook security issues when the objective is to write a piece of software that runs and does its job.

Internet Explorer has has its share of buffer overflow problems. It is a large piece of software that has been developed over a long period of time, small security problems are likely to exist all over the browser.

One way to eliminate a buffer overflow type error is to use a platform that doesn’t allow buffer overflows to occur. Microsoft’s .NET Framework Common Language Runtime (CLR) is one such platform. Like Java which uses bytecode and a Java Virtual Machine to execute programs, the CLR runs as a virtual machine, which runs applications written and compiled for the .NET platform. The virtual machine performs checks on data that is being processed, and if it finds a problem, an exception will be thrown which in turn must be dealt with in some way.

Microsoft may want to consider start rewriting Internet Explorer with .NET. Running the browser on a virtual machine itself may already take a lot of the security risks that arise from exploits that use buffer overflows. There are of course other security issues that Internet Explorer have due to the features it support, such as ActiveX controls which can execute code directly on the user’s computer.

It may be interesting to note writing services in Windows with .NET and running it on the CLR was one of the original plans for Windows Vista, but eventually that was tossed out as it approached release.

Rewriting Internet Explorer may be a radical step to take, but considering that it is the browser with the top market share means that it should be taking the security of its software seriously. Writing Internet Explorer for the .NET Framework may be one way that Microsoft can be a responsible citizen and provide a product that is a little bit safer than it is today.

Fast forward six years, we are talking about dual core processors; a processor containing, in essence, two processors. Then in September, Intel announced a prototype 80-core processor, which may be an indication of the trend for the evolution of microprocessors in the next few years. This speculation can be backed up by the efforts by both AMD and Intel to bring quad core processors to the market.

This continual push for more computing power brings up an interesting point. It seems like we may start to actually get to a point where we may be having excess computing power to the point that software which would have been deemed “inefficient” or “wasteful” could become practical. While this may sound odd, it has some serious implications for future software design.

Part 2 will discuss running software on virtual machines to enhance security and portability.