EETimes.com is reporting that according to ABI Research, ARM will overtake the Netbook market by 2014. This is exciting for a couple of reasons. ARM is just an IP supplier; it’s still up to foundries to make the chips. Also, the nature of ARM devices is that they can be easily modified by third parties. This means the CPU market will be much more diverse than it has been for a while. The other exciting reason is that Windows (except for Windows mobile, which is worthless) doesn’t currently run on ARM architectures. We will most likely have much more Linux out there. Either that, or Microsoft steps up their effort on ARM architectures, which is also exciting.

There is much discussion of i4i’s U.S. Patent #5787449 and their request for an injunction of the sale of Microsoft Word. Unfortunately, many people have the wrong idea of what is happening. The patent deals specifically with the implementation of a certain feature in word - the ability to add your own custom XML schema and tags to a document. This is not about the .docx format, and it isn’t about the feature itself; it is about the feature’s implementation.

XML documents are structured documents. The structure is represented by tags within the content such as the following:
<document id = "112358"> <type>book</type> <title>A guide to writing guides</title> <author>Jane Doe</author> <publisher>McPublisher</publisher> </document>
This code is meant to be machine and human readable. Typically, a person will view the document with a special program that transforms the document into a more presentable format and shows the relevant information, formatted in a way that is easier to read, without the tags in the way.

A challenge comes when it is time to edit the document. A person could certainly edit the code directly; it is, after all, meant to be accessible to both humans and machines. This method, however, can lead to errors. It is also taxing on the person to have to enter the tags manually. It would be much better if the person could edit it the way it looks when it is presented nicely.

There are a couple of ways that might immediately come to mind about how a computer program might be written to do this. The first is to display the document in a well-formatted way, and have the tags be present in the document, but not visible to the user. The other way this could be accomplished is to have the document represented internally in a different way - the content is in one piece like this:
112358 A guide to writing guides Jane Doe McPublisher
and the structural information is in another piece, separate from the content. One might imagine a list of tags and pointers that point to character locations of where they belong:
document 0 title 9 author 37 publisher 48 ...
The second piece is a map that assigns certain tags at certain locations in the document.

It is apparently Microsoft’s Custom XML feature that implements this mapping method and that may be infringing the patent. The patent actually doesn’t specifically reference XML, it is more generally for any separation of document and its structure. However, the company specifically makes software that deals with XML in this manner, and this is what they are looking for an injunction for. I will be very surprised if the patent is ultimately found to be valid; there must be some prior art for this method.

I hope that this explanation helps to clear some confusion surrounding the issue. If you have an observation to add, please leave a comment below.

This article is prompted by the recent news of Gnome considering a vote to split from the GNU project. The GNU project is a software development effort to create a free Unix-like operating system. Indeed, much of the software tools used in Linux (a Unix-like operating system) was created by the GNU project. Much of the philosophy of the GNU project came from its founder, Richard Stallman. Stallman advocates that free (as in freedom) software is the only acceptable kind; any software that removes a person’s freedom is an assault to that person’s inalienable rights. Stallman’s definition of freedom includes a person’s rights to run a program for any purpose, to redistribute the program (either for no cost or for a fee), to modify that program to suit his needs, and to distribute the modified program.

A bit after the GNU project had gained some momentum, Linus Torvalds saw the use of the software tools created by the GNU project. Torvalds had been working on his own project: an operating system kernel called Linux. The GNU project by that time (around 1991) had released some quality software, which Torvalds saw fit to include with his operating system.

Over time, the GNU project also created a software license called the GNU GPL. The license codified Stallman’s philosophy into a legal document. It included terms that required distributors of GPL-licensed software to also distribute the source code to that software. Also, any GPL-licensed software that was modified also had to have the modified source code distributed with the with it. Torvalds wanted to distribute Linux for free and realized that having any modified versions of his code would be beneficial, since he could then incorporate that modification in his own system. Because of this, Torvalds released Linux under a GNU GPL license. Many other people followed suit.

At that moment, two different people with different goals shared a similar means. Ever since then, people of one mindset or the other would associate themselves with the seemingly same community. They called it the Free Open Source Software (FOSS) community. It has seemed to work okay for a while, although there has always been some amount of friction between those who are in it for pragmatic reasons and those who fight for the human right to free software. The pragmatists are making deals with companies that produce proprietary software. The GNU crowd is making very public, very bold statements that don’t represent the views of everyone involved. This friction has begun to start fires.

Arguing for one viewpoint or another is not going to tear “the community” apart, as some people believe is happening. This is not a community to be torn apart; it is two different communities, and it’s time for people to realize that. I do believe that once this becomes accepted, people will be much happier and more productive.

What do you think? Two communities? One community? Post your comments.

In my communications for engineers class, we had an assignment to write a paper in the style of a technical journal in our industry. Since the subject of extensible processors has recently caught my interest, that was the topic of my paper, and of course, it is in the IEEE Transactions format. You can download and read the paper here.

In my previous post, I mentioned an article where the author suggested using customized processors to implement a system on a chip. Another interesting topic is somewhat related, but from the opposite direction - the subject of extensible processors. It involves the improvement of general processors by adding custom logic.

Microsoft Research has an architecture they’ve developed called eMIPS, which takes a MIPS processor and adds an FPGA that has access to each datapath stage. This allows for a dynamically reconfigurable bit of logic to implement custom instruction extensions. There are even tools that enable you to pick a block of machine code out of a program and automatically generate the custom logic to implement it - this is done with software tool called MIPS-to-Verilog. Using another program (BBTools), the new instructions that invoke the custom logic are automatically inserted into the program and the original code stays there as a software fallback. This software fall back can be useful if, for instance, the operating system didn’t allow the program to add the custom logic because a higher priority program was already using the FPGA extension.

I would also point out that this setup resolves the CISC/RISC dilemma. Some processing tasks which can be done on a simpler RISC architecture can be done much faster if these tasks are implemented directly in hardware (leading to a CISC architecture), however, there are very many such tasks: choosing the ones that make it into an architecture is difficult. Additionally, every task that is implemented complicates the processor and makes it more difficult to debug and generally optimize. Since an extensible processor can have the custom logic reprogrammed on the fly, the programmer (or perhaps a sophisticated compiler) gets to insert whatever additional logic is needed.