Random Thoughts – Randocity!

Patent Trolls or why software patents should be abolished!

Posted in business, free enterprise, politics by commorancy on May 21, 2011

The patent system was originally designed to provide exclusive rights for invented ideas to inventors. But, there used to be a catch, the idea must lead to a real world tangible device. The patent system was also conceived long before computers existed. So, at the time when the patent system was conceived, it was designed as a way for inventors to retain exclusive control over their ideas for tangible devices without other people stealing or profiting from those ideas.

The patent system is enforced by the legal system. It is sanctioned by governments (specifically in the US, by the US Patent Office – USPTO and the legislative system) to protect said individuals’ patents from use by others who serve to profit from those previously ‘patented’ ideas. So, enforcing a patent involves suing an alleged infringer and then having a court of law rule whether the alleged infringer has, in fact, infringed. It is, then, the burden of proof of the patent holder to prove infringement.  And, of course, it ties up the legal system to resolve this dispute.

Tangible vs Intangible Devices

The patent system was conceived at a time when the ultimate outcome of a patent idea was to produce a tangible physical good. That is, something that ultimately exists in the real world like a pen, a toaster, a drill, a telephone or a light bulb. The patented idea itself is not tangible, but the idea described within the patent should ultimately produce a tangible real world item if actually built. This is why ideas that lead to intangible things were never allowed to be patented and are only allowed to be copyrighted or trademarked.

Fast forward to when the first computers came into existence (30s-60s). Then later, the 70s when the US Patent Office began granting software patents en masse (although, the first software patent was apparently granted in 1966). Software, unfortunately, is not a tangible thing and, for the most part, is simply a set of ideas expressed through a ‘programming language’ with finite constructs. Modern programming languages, specifically, are designed to have limited constructs to produce a structured code. That is, an application that follows a specific set of pre-built rules to basically take data in and present data out (in specific unique ways).  Ultimately, that’s what a program does, take data in, process it and spit data out in a new way.

Software Design Limits

Because modern programming languages have limited constructs from which to build an application and which are further constrained by such limits as application programming interface (API) frameworks, operating system function calls, hardware limitations and other such constraints, writing an application becomes an exercise in compromise. That is, you must compromise programming flexibility for the ease and speed of using someone else’s API framework. Of course, you can write anything you want from scratch if you really want, but most people choose to use pre-existing frameworks to speed the development process.  Using external frameworks also reduce time to completion of a project. At the same time, including third party API systems is not without its share of coding and legal issues. Programmatically speaking, using a third party API opens up your code to security problems and puts implicit trust into that API that it’s ‘doing the right thing’. Clearly, the functionality derived from the external framework may outweigh the security dangers present within the framework. From a legal perspective, you also don’t know what legal traps your application may fall into as a result of using someone else’s API framework. If they used code within the framework that is legally questionable, that will also bring your application into question because you used that framework inside your app (unless, of course, it’s using a SOAP/REST internet framework).

With all that said, embedding frameworks in your app severely constricts your ability to control what your program is doing. Worse, though, if you are using a high level programming language like C, C++, Objective C, C# or any other high level language, you are limited by that programming language’s built-in construct. So, even if you choose to code everything from scratch, it’s very likely you could write code substantially similar to something that someone else has already written. Because high level languages have limited constructs, there are only so many ways to build an application that, for example, extracts data from a database. So, you have to follow the same conventions as everyone else to accomplish this same task.

Software Patents are bad

Because of these limited high level language constructs, there is a high probability that someone writing an application will write code that has already been written hundreds of times before. And note, that’s not an accident. That happens because do()while, for() and while() loops as well as if conditionals area always used in the same way. Worse, you can’t deviate from these language constructs because they are always the same in pretty much any language.  If these constructs didn’t exist, you couldn’t easily make decisions within your code (ie, if X is greater than 3, do this, else do that).

Why are software patents bad? Simply, because languages are written with such limited programming concepts, the probability to reinvent something that has already been invented is far too high. Unlike devising a real world idea where the probability someone could come up with that same exact idea is likely near zero, writing software using language constructs the probability is far higher than 70% that someone could design the same (or substantially similar) code, idea or construct. And. that high probability is strictly because of the limits and constructs imposed by the high level language.

Yet, the USPTO has decided to allow and grant software patents knowing the probabilities of creating substantially similar ideas within the software world is that high. Yes, probabilities should play a part in whether or not to grant patents.


Probability in idea creation is (and should always be considered) how likely someone is to create something substantially similar to someone else. Probability should always be relevant in granting patents. Patents need to be unique and individual. That is, a patent should be granted based on something that multiple people could not devise, guess, build or otherwise conceive accidentally. Because real world tangible items are constrained only by the elements here on Earth, this effectively makes inventions using Earth elements pretty much infinite (at least for all intents and purposes). Because software code uses a much smaller number of constructs that limit and constrain programming efforts, that smaller set increases the chances and the probabilities that someone can create something similar.  In fact, it increases probabilities by orders of magnitudes. I’m sure an expert on statistics and probabilities could even come up with real world probability numbers between element based inventions and software code based inventions. Suffice it to say, even without this analysis, it’s quite clear that it’s far too easy for someone to devise something substantially similar in software without even really trying.

Software patents are bad, revisited

Basically, it’s far too easy for someone to devise something someone else has already conceived using software. On top of this, the USPTO has seen fit to grant software patents that are way too obvious anyway. That is, they’ve granted patents to software ideas that are similarly as common place as cotton, strawberries, a nail and yarn. Worse, because of these completely obvious patents, patent trolls (people who do nothing but patent without the intent of producing anything) game the system and produce completely obvious patents. This action has created a land mine situation for the software industry.  This is especially bad because it’s virtually impossible to search for existing patents before writing software.

So, as a software developer, you never know when you might step on one of these land mines and get a ‘cease and desist’ notification from a patent troll. That is, someone who has patented some tiny little thing that’s completely obvious, yet your application takes advantage of that thing somewhere because you just happened upon one of the easy to build constructs in a language. Yet, patents should only be granted based on an idea that someone cannot easily create by sheer accident. Yet, here we are.

Ideas now patented

Worse, software is not and has never been tangible. That is, software doesn’t and cannot exist in the real world. Yes, software exists on real world devices, but that software itself is just a series of bits in a storage device. It is not real and will never be real or ever see the light of day. That is, software is just an idea. An idea with a structured format. It is not real and will never have a real tangible physical shape, like a toaster. We will never be able to have tactile interaction with software. Hardware, yes, is tactile. Software, no. The software’s running code itself cannot stimulate any of our five senses: not sight, hearing, touch, smell and taste.. Someone might argue, well software does produce visual and audible interaction. Yes, the output of the software produces these interactions. That is, the software processes the input data and produces output data. The input and output data has sight and sound interaction. You still aren’t seeing or hearing the software code doing the processing. That’s under the hood and cannot be experienced by our five senses. For this reason, software is strictly an idea, a construct. It is not a tangible good.

Patents are a form of personal law

That is, the owner of the patent now has a legal ‘law’ that they need to personally enforce.  That is, that patent number gives them the right to take anyone to court to enforce their ‘law’ err.. patent.  No entity in government should be allowed to grant personal law.  Especially not for intangible things.  I can understand granting patents on tangible items (a specialty hair clip, a curling iron, a new type of pen, etc).  That makes sense and it’s easy to see infringement as you can see and touch the fake.  It takes effort, time and money to produce such a tangible item. Software patents require nothing.  Just an application to the USPTO, a payment and then wait for it to be granted.  After the patent has been granted, take people to court, win and wait for royalties.  This is wrong.

All software patents should be immediately abolished and invalidated


  • Software patents only serve corporations in money making ventures. Yet, software patents really serve to bog down the legal system with unnecessary actions.
  • Software patents stifle innovation due to ‘land mines’. Many would-be developers steer clear of writing any code for fear of the legal traps.
  • Software patents are granted based on probabilities far too high that someone will produce something similar based on limited high level language constructs
  • Because software language constructs are, by comparison, much smaller in number when compared to Earth elements (when inventing real world ideas), probabilities say it’s too easy to recreate something substantially similar to someone else in software.
  • Software is intangible and cannot expose itself as anything tangible (which goes against the original idea of patents in the first place)
  • Software patents will reach critical mass.  Eventually, the only people left writing code will be large corporations who can afford to defend against legal traps.
  • Software patents are now being granted without regards to obviousness.

As a result, all software patents, past and present, should be immediately invalidated.  If we continue this path of software patents, a critical mass will eventually exist such that writing software will become such a legal landmine that developers will simply stop developing.  I believe we’ve already seen the beginnings of this. Eventually, the only people left who can afford to develop software will be large corporations with deep pockets.  Effectively, software patents will stifle innovation to the point that small developers will no longer be able to legally defend against the Patent Trolls and large corporations seeking to make money off ‘licensing’. The patent system needs to go back to a time when the only patents granted were patents describing tangible physical goods. Patents that do not describe tangible physical goods should be considered ideas and dumped under copyright law only.

iPad: One year later…

Posted in Apple, cloud computing, computers, ipad by commorancy on May 8, 2011

The iPad was introduced very close to this time last year.  Now the iPad 2 is out, let’s see how it’s well it’s going for Apple and for this platform as a whole.

Tablet Format

The tablet format seems like it should be a well-adopted platform. But, does the iPad (or any tablet) really have many use cases?  Yes, but not where you think. I’m not sure Apple even knew the potential use cases for a tablet format before releasing it. Apple just saw that they needed a netbook competitor, so they decided to go with the iPad. I am speculating that Apple released it with as wide an array of software and development tools to see exactly where it could go. After all, they likely had no idea if it would even take off.

Yes, the iPad has had a widely and wildly accepted adoption rate.  Although, market saturation is probably close at hand with the numbers of iPads sold combined with the Android tablet entries (Samsung’s Galaxy S, Toshiba’s tablet and other tablets out or about to be released).  That is, those people who want a tablet now can have one. But, the main question is, what are most people using a tablet for?

My Usage

I received an iPad as a gift (the original iPad, not the iPad 2). I find myself using it at work to take notes first and foremost. I can also use it as a systems admin tool in a pinch. However, instead of carrying paper and pencil into a meeting, I take notes in the notepad app. This is actually a very good app for taking quick notes. Tap typing is nearly silent, so no clicky key noises or distracting pencils. The good thing, though, is that these notes will sync with Gmail and you can read all your notes in Gmail. You can’t modify the notes on Gmail, but at least you have them there. You can modify them on the iPad, though.  You can also sync your notes to other places as well.

My second use case is watching movies. So, I have put nearly my entire collection of movies on the iPad. Of course, they don’t all fit in 32GB, so I have to pick and choose which ones get loaded. The one thing the iPad needs, for this purpose, is more local storage. I’d like to have a 128GB or 256GB storage system for the iPad. With that amount of space, I could probably carry around my entire movie collection. In fact, I’d forgo the thinness of the iPad 2 by adding thickness to support a solid state 256GB drive.

The rest of my use cases involve reading email and searching and, sometimes, listening to music… although, I have an iPod touch for that.  I might listen to music more if it had a 256GB solid state drive.

Cloud Computing and Google

This article would be remiss by not discussing competition to the iPad.  There is one thing about Google’s Android platform that should be said.  Android is completely integrated with Google’s platform.  Apple’s iPad isn’t.  Google has a huge array of already functional and soon-to-be-released cloud apps that Android can take advantage of.  Apple, on the other hand, is extremely weak on cloud apps.  The only cloud app they have is the iTunes store.   That, in fact, is really a store and not a cloud app.  So, excluding iTunes, there really isn’t any cloud platforms for Apple’s devices.  That’s not to say that the iPad is excluded from Google, it’s just not nearly as integrated as an Android tablet.

Eventually, Android may exceed the capabilities of Apple’s IOS platform.  In some ways, it already has (at least in cloud computing offerings).  However, Android is still quite a bit more buggy when compared to IOS. IOS’s interface is much more streamlined, slick and consistent.  The touch typing system is far easier to use on an iPad than on Android. Finally, the graphics performance on Android is incredibly bad. With Android, the scrolling and movement is choppy using an extremely slow frame rate.  Apple’s interface is much more fluid and smooth and uses a high framerate.  The transitions between various apps is clean and smooth in IOS, but not in Android.  This graphics performance issue Google must address in Android.  A choppy slow interface is not pretty and makes the platform seem cheap and underpowered.  Worse, the platform is inconsistent from manufacturer to manufacturer (icons are different between manufacturers).  Google has to addresses these performance and consistency issues to bring Android to the level where it must be.

Apple’s Blinders

That said, the iPad (or more specifically Apple) needs to strengthen its cloud offerings.  If that means partnering with Google, then so be it.  Apple needs something like Google Docs and Google Voice.  It also needs cloud storage.  It needs to create these offerings that are Apple branded that integrate with the iPad natively, not as third party add-ons through the app store.  This is what Apple needs to work on.  Apple is so focused on its hardware and making the next device that it’s forgetting that it needs to support its current devices with more and better cloud offerings.  This is what may lead Apple out of the tablet race. This may also be what makes Google the leader in this space.

So, what things do you use your iPad for?

Let’s Find Out

Poll 1 Poll 2
Tagged with: , , ,

Apple’s bleeding edge

Posted in Apple by commorancy on May 1, 2011

Apple loves to adopt brand new bleeding edge technologies and shun existing functional and supported technologies.  Case in point, Apple’s new MacBook Pro line sports a new Thunderbolt (Lightpeak) port. So, yeah, while this port is capable of 10Gb per second, there are no peripherals yet available for this technology.  But, instead of placing USB 3 ports (capable of 5Gb per second) onto the MacBook Pro, they instead decided to skip this recent technology.  So, the MacBook Pro comes shipped with dog slow USB 2.0 ports running at a whopping 480Mb per second.  That’s ok if the only thing you want to transfer is sync data to your iPhone or iPad. For hard drives, this speed is unbearably slow.

Apple’s own stupidity

We don’t want ports with no peripheral support.  We want ports that are actually supported.  Simply because Apple has adopted the Thunderbolt technology doesn’t mean that it will in any way become a standard.  In fact, Apple’s bleeding edge adoption of the Thunderbolt port is about as risky as the Firewire (1394) port was way back when. And, where is Firewire now?  Dead.

I just don’t get why you would stick old technology on a brand new notebook when new technology already exists?  There are many USB 3 adapters and peripherals that could easily get users faster speeds until (or if) Thunderbolt actually takes off.

Apple needs to wake up and realize we want to connect fast drives to external ports.  So, at least give us ports where we can do this.  Sure, LaCie and other manufacturers will likely start making Thunderbolt compatible drive enclosures, but they probably won’t hit stores for months or possibly even as late as 2012. Until then, we have to live with USB 2.0 ports that suck rocks for speed.

Thanks Apple.

Tagged with: ,
%d bloggers like this: