Interesting turn of events in Open Source Hardware

From Make Blog: What is your definition of Open Source Hardware?

The discussion is very interesting, and is relevant to those who want to know all the business ins and outs of Open Source. The thing that is very interesting is the whole non-commercial aspect. In the article that was mentioned above, people used a Creative Commons – Non-Commercial – Share Alike License for the project and because of the licence, LadyAda mentioned that it could not be Open Source Hardware. This seemed to have become an issue because people are afraid of people profiteering off of their resources and credit not being given.

The thing is that all Open Source licences protect from profiteering. The granddaddy of them all, and the one that Nitobi uses is the GPL. The GPL is really putting everything out there. What is says is that as long as we distribute code, you will be able to do the following:

  • Freedom 0: The freedom to run the program for any purpose.
  • Freedom 1: The freedom to study and modify the program.
  • Freedom 2: The freedom to copy the program so you can help your neighbor.
  • Freedom 3: The freedom to improve the program, and release your improvements to the public, so that the whole community benefits.

It doesn’t say anything about who can use it. It says the public, which would mean that anyone can use it. If you make it non-commercial, it means that Freedom 3 is gone. From an idealistic point of view, it may sound good, but in reality, it shoots you in the foot, and dooms the project to be forever a side-project and limits the opportunities for people to participate. However, what would be best practice for this case is to dual license your project under a more permissive licence. This is what Mozilla does with Firefox. Despite what people like RMS would tell you, Dual-Licensing code is a good idea, and it allows you to have dialog with the people who are using your code, whether they agree with the goals of Free and Open Source Software or not.

Still, it’s interesting seeing Open Source Hardware have these discussions, since it seems that in software, they’ve gotten rather entrenched as of late.

Android goes Open Source, Start your Hacking!

I’m really glad that Google Open Sourced their Android Stack. It was the right thing to do, and it now makes the Neo1973 relevant again. For those of you who rememer, the Neo1973 and the FreeRunner is a “Free Phone”, which runs Free Software and runs either a GTK or a QT based interface. It was a buggy phone that lacked the features that the iPhone had, not because of the hardware, but because of the software. The thing included a Guitar Pick and generally was a hacker’s phone.

However, early on there were some issues getting Android to run on it. However, now that we have the code, it’s just a matter of compiling it for the right processor. This means that the Neo1973 may not be a useless piece of junk after all and may still have some sort of a use.

The other thing that is cool is that people can create interesting new tools with the iPhone that required low-level access to the hardware, and people can study the phone and the source for vulnerabilities, and other cool things. Releasing the source makes things far more hackable, and the more hackable the device is, the more likely I’ll get one. I still subscribe to the philosophy that if you can’t take it apart, you don’t really own it.

Update: The status can be found here: This may be the way to go once it’s going.

PhoneGap, now for Android

Recently, I’ve been looking at PhoneGap. However, unlike most people at Nitobi, I am using a PC. However, I spend most of my time running Ubuntu Hardy Heron on my dual-boot system. This means that unless I wanted to jailbreak a phone, there’s really no way that I could do iPhone Development. However, the other day I decided to start taking a look at the Android SDK when the G1 was announced. It’ll be a while since we’ll get any Android phones in Canada (for more info, read this), it’ll be good for the rest of the planet to have the ability to write once and run anywhere. Sort of like what Dave said.

One thing that is interesting is that Google embraced the idea of using HTML and Javascript inside of their apps and they have their own demo apps that use this. This definitely made it a lot easier to write the app:

Of course, I’m currently relying on the Emulator and the Eclipse plugins to test this, which is different from the real world, however if someone wants to help make the world of Javascript-based Mobile Applications better, it would be great if we had a real device of some sort that we could use for this. ;)

This also hasn’t been merged into the official repo yet, and currently lives on my GitHub: It’s been a while since I’ve hacked on Java, so the code is probably cruftier than it needs to be. It’d be interesting to see where this platform goes.

MerbCamp 2008 Review

I just got back from MerbCamp 2008, and now I’m writing a blog entry on my slow PHP WordPress application. I can say this with confidence because of the fact that every time this blog loads, it has to re-parse and re-interpret the PHP, which pulls from the database the blog entries that I’m using. The reason I’m mentioning this is because of the closing keynote.

In the closing keynote, Yehuda Katz brought up a very important point, which is that Fibonacci Numbers and Matrix Multiplication are not necessarily good benchmarks for language to be measured on as far as building a web framework. When people think that Ruby is slow, it is based on the fact that during the Programming Language shootout, it does poorly. It is tested classically against other languages with the same general purpose tasks that define a language. This means that instead of testing frameworks, and extensions and adapters, it’s testing pure Ruby against pure C, pure Java, pure C#, pure Python and pure PHP (Whatever that means).

However, given the fact that a LOT of the gems used in running a framework are natively compiled in C and work with Ruby this means that a lot of the things that Ruby is inherently bad at can be mitigated. It’s true that Ruby is not a magic bullet, nor is php or any other language. The fact of the matter is that Ruby is not as slow as people make it out to be.

On another note, the best thing about the conference IMO is the fact that it was webcast and archived. This is great because I missed part of the Sunday morning presentation about Deploying Merb. Right now, I really want to find a Web-Based Service where I can just create a ton of Virtual Machines that I can use for staging. I know that we have spent countless hours here setting up servers using Apache, Nginx, Mongrel as well as personally with mod_rails and mod_rack. If that could be automated every time we need another Rails or Merb solution, that would be a major epic win for us. I know that EngineYard has come close, but then again I’m a server geek who likes to be able to have the ability to tweak everything, but doesn’t have the time.

Another thing that was cool was the IRC. I spend a LOT of time on IRC. I used to practically live on #openwrt back when I was doing hacking on the Linksys router, and on #wireless. These days I can be found in #freegeek-van, #merb, #arduino, #vhs and in #nitobi on FreeNode. Yes, I said #nitobi. (I registered #nitobi for the official Nitobi channel on FreeNode, but more on this at a later time.) Anyway, Brian and Rob had to get back onto IRC at the sprint. It’s hard to keep track of everything that goes on, but IRC definitely has stood the test of time for one to many chat, and for getting help fast. The coolest thing about the IRC was the end where everyone used IRC to ask questions of the Merb team. The reason for this is because MerbCamp was webcasted and people from around the world were asking questions. Apparently this is commonplace at various conference, but it’s the first time I’ve experienced it professionally, which is rather cool.

Overall, it was a cool conference, and I’m looking forward to going next year.

Android Webkit Tutorial

Recently, I’ve been playing with the Android SDK. The main thing that has me pumped about Android is the fact that it’s open and the fact that I can actually write code for it without having to get a Mac and run Mac OS X. I’ve been messing around with it a couple weeks, and I found that there wasn’t a good set of code samples for developing with Android.

So, here’s a rough description of what you need to do to get a WebView to actually be useful in Android. First of all, you should already be familiar with the basics, since we’re not going to be spending too much time on them here. You need to use the following in the layout:

            < WebView android:id="@+id/appView"
            android:layout_width="fill_parent" />

This should be in a layout element in your XML Layout. I use the Linear Layout similar to the tutorial, but you may want to use a different layout. Then, I started using it with the following Java code:

WebView appView;
appView = (WebView) findViewById(;

This code should be put in the onCreate method of the activity, since this will be loaded at the beginning of the activity. This is the most basic way to make sure that you get a full running browser. It’s something that I didn’t find straight forward from the API docs, so I figured that I’d pass this thing on. It’ll be a while since I’ll be getting one of these phones, since I’m in Canada, but I have a feeling that this will be coming up again very soon.