I am happy to report that the new Found Line website has launched! This new version includes some much needed content and visual updates and is now running in Zend Framework (although there is very little functionality beyond static content). All of the visual effects use jQuery, there is no Flash to be found on the site, and all behavior should degrade gracefully if JavaScript is not enabled. The site is almost entirely valid XHTML and CSS – the only exceptions are a couple of visual effects that required a bit of hacking (but we’re hoping to find a valid XHTML alternative). The site has been checked for cross-browser compatibility in 25+ browser/OS combinations. It has also been tested in a text only browser and should be accessible to screen readers. Please take a look and let me know your thoughts – good, bad, or indifferent!
Richard M. Stallman (RMS), founder of the free software movement and the Free Software Foundation (FSF), gave a speech on Copyright vs. Community at Saint Michael’s College on Thursday evening, and then a speech on The Free Software Movement at Champlain College on Friday morning. While I don’t agree with all of his ideas, here are a few interesting pieces from his talks.
He equates software freedom with human rights and says that we should have the following four freedoms when it comes to software:
- “The freedom to run the program, for any purpose (freedom 0).
- The freedom to study how the program works, and adapt it to your needs (freedom 1). Access to the source code is a precondition for this.
- The freedom to redistribute copies so you can help your neighbor (freedom 2).
- The freedom to improve the program, and release your improvements to the public, so that the whole community benefits (freedom 3). Access to the source code is a precondition for this.”
RMS seemed more comfortable during his Free Software Movement speech and bit out of his depth in the Copyright vs. Community speech. While I believe he has done a lot of research and thinking about the issue, his attempts to apply these four freedoms to works other than software seemed a bit strained. Having said that, I completely agree that the current copyright system is broken and needs to be fixed to give people more freedom. I am just not sure that the fix is as simple as what he proposes (at least for non-software works).
I completely agree that it is an educational institutions moral duty to only use free software (free as in speech, not free as in beer). I would be interested in hearing from people who have had success in convincing education institutions to switch to free software. I would extend this argument to say that it is the moral duty of our government to only use free software. If it’s payed for with taxpayer money then we should have the four freedoms on that software.
April 16, 2008 – 10:30 am
The first full review of the Asus Eee PC 900 is available. The Eee PC is an ultra-portable computer and this newest version sports the following features:
- 8.9 inch 1024×600 LCD
- 1 GB of RAM
- Linux or Windows XP
- 20 GB SSD (Linux version) or 12 GB SSD (Windows XP version)
- 900 MHz Intel Celeron CPU
- 1.3 megapixel webcam
- measures 225 x 165 x 35 mm (8.86 x 6.50 x 1.4 in) (WxDxH)
- weighs about 1 kg (2.2 pounds)
Unfortunately the PC 900 isn’t available in the US yet. Rumor is that it will have a $499 price tag when it’s available here.
I find it interesting that the Eee PC is helping to push Linux on the desktop (well, on the ultra-portable) through the installed Xandros distribution. However, I would probably install eeeXubuntu if I were to get an Eee PC. I would have no interest in running Windows XP on the Eee PC.
The Seattle Post-Intelligencer has an article about the Dalai Lama’s comments during a panel discussion at the recent Seeds of Compassion conference. The audience was a group of business and policy leaders. The article takes a compassionate look at doing business. One interesting quote when asked about competition in business:
“If your colleague (is a) little bit lazy, or something like that, you try to be more competitive. So that is the positive side,” he said. “Negative side — to be causing one trouble.”
I find this interesting because what he is saying parallels the theory of capitalism in which competition is healthy as it creates better products and services. But, he is also addressing the reality of capitalism where individual businesses may see competition as something to be crushed. If you take the world view that we are all interconnected (whether this is through religious or secular belief) then harm caused to another causes suffering for all:
“If you do good, you get positive result. Something that creates harm is bad because we do not want to create suffering.”
Apparently there is quantitative research that shows that compassionate companies tend to outperform the market. I’m not sure, exactly, how compassion is measured or how statistically accurate this research is. However, I’m inclined to believe in the concept.
Google has just launched a preview release of the Google App Engine. Developers can now create web applications and run them on Google’s infrastructure. This gives developers access to a lot of the same tools that Google uses to build its own web applications including GFS and Bigtable. Unfortunately, it’s only available for Python and the Django web application framework at the moment but “other programming languages and runtime environment configurations are being considered for future releases.” I’m hoping Google is considering support for PHP and Zend Framework in the Google App Engine.
In a previous post I talked about Plain Old Semantic HTML (POSH). The POSH concept saved us a lot of time and frustration on a recent project. Our task was to create a cold water wash calculator for Seventh Generation’s Get Out of Hot Water for Earth Day promotion. The calculator takes four inputs: water temperature, type of hot water heater, type of clothes washer, and loads per week. It then tells you the savings if you switch to (or are already using) cold water, an Energy Star washer, and/or 2X Concentrate Natural Laundry Detergent.
They wanted a smooth user experience. This sort of thing would normally be created in Flash but we decided to use XHTML + CSS + jQuery instead. The first step was to create functional and technical specifications. The specifications (and looking through all of the calculations to make sure we understand everything correctly) were actually a big part of the project. After that we moved into production.
We had two people working on this project – I implemented the functionality in jQuery and Jason implemented the design in CSS. We spent the first two hours working together on getting the semantic XHTML correct. Once we had the semantic XHTML we essentially had an API that we both could use to do our work. It was worth the time upfront getting this part right.
Next we went to our respective corners. I created the jQuery functionality selecting and manipulating the DOM using CSS selectors. Jason used the XHTML structure we had come up with to add CSS and make it all look pretty. The great part was that, since we had come up with the the XHTML structure as the one touch point, we were each able to do our jobs without hardly bothering the other person to ask questions or make changes.
Of course, there were a few changes needed to the XHTML once we started working on our individual pieces – we’re not perfect after all. This is were Subversion came in handy. I could change my local copy and when I was sure I wanted to I could commit that change and Jason could update his local copy merging any of his own changes (or vice-versa). The whole process went quite smoothly and we’re very happy with the results (the “Switch to Cold Water and Save” calculator on the right).
Web developers have many options to choose from when it comes to web services. These options include SOAP, XML-RPC, and REST. It is my opinion that REST will emerge as the primary web services “protocol.” The advantages and disadvantages of each protocol is a topic that has been discussed to great length online. Here are the primary reasons why I think REST has the advantage:
- REST is simple. Time and time again, simple has won on the web. The web itself is successful because of its simplicity. People are really good at making things more complicated than they need to be (which is why we have SOAP).
- REST builds on the simple concepts that make the web work. URLs are resources/nouns that can have HTTP methods/verbs such as GET, POST, PUT, and DELETE applied to them.
- It does not dictate what the actual data will look like. This is seen as a weakness by many but why should this be the domain of the web service protocol? Here you can pick what works best for the data you are communicating. Perhaps XML defined through XML Schema, DTD, or RELAX NG is best for a particular use case. Maybe you’d prefer to use JSON instead. Maybe you simply want to use (X)HTML and microformats. Maybe you’re dealing with binary data that isn’t machine-readable such as images or PDFs. If it can be represented by a URL and can be gotten (GET), posted (POST), put (PUT), and/or deleted (DELETE) it’s RESTful.
Here is some interesting reading on REST:
Magento 1.0 has just been announced. Magento is an open source eCommerce platform based on Zend Framework. I’ve used several shopping cart applications in the past and have been very disappointed with all of them. Magento looks promising and I hope to demo it soon.
Artima has an older (but still relevant and interesting) interview with Josh Bloch, a Sun Microsystems Architect. While the interview focuses on Java, Josh Bloch has some interesting things to say about software design in general. The main topic is thinking about design in terms of APIs instead of monolithic software construction.
Reuse is extremely important but difficult to achieve. You don’t get it for free, but it is achievable.
The lure of object-oriented programming is the ability to reuse code. However, creating reusable code is not as simple as switching from procedural to object-oriented programming. One may make the switch from procedural to object-oriented programming and then be disappointed that object-oriented programming didn’t deliver on the promise of reuse. Josh Bloch has a potential solution to this problem but it requires one to think about software in terms of public APIs.
Being disappointed with object-oriented programming, one may then decide to try agile programming, perhaps even extreme programming. One tenant of extreme programming is to “do the simplest thing that could possible work.” Josh Bloch points out that this is easy to misconstrue:
The extreme programming proponents don’t advocate writing something that will barely work as fast as you can. They don’t advise you to forgo any design. They do advocate leaving out the bells, whistles, and features you don’t need and add them later, if a real need is demonstrated. And that’s incredibly important, because you can always add a feature, but you can never take it out. Once a feature is there, you can’t say, sorry, we screwed up, we want to take it out because other code now depends on it. People will scream. So, when in doubt, leave it out.
He goes on to talk about other topics such as minimizing mutability, protected vs. private members, when to make a class final, and the copy constructor as a cloning mechanism. It is interesting reading if you are striving for the goal of reusable object-oriented code.
Cal Evans has a post talking about his experience at the Open Source Business Conference (OSBC). Just like many small businesses, especially web development shops, open source software is a critical tool for us at Found Line. However, I’d like us to be more then just consumers of open source software. It seems like most discussions about open source business focus on the large companies that sponsor open source projects. Where’s the business model for small businesses in open source? Small businesses like ours typically don’t start open open source projects but we can be a part of an existing project.
Sure, there doesn’t need to be a “business model” for companies like ours to contribute back to open source. I certainly see the value in contributing back to open source and would like to do so even without any clear picture of how it’s good for our bottom-line. But, in order for it to be part of a small companies business plan there needs to at least some basic understanding of how it contributes to the business’ overall success. Here are few arguments I can make for why a small business should contribute back to open source software:
- It helps to ensure that the open source software your business relies on survives and thrives.
- It can help attract talent. With proprietary software there is a bigger risk that everything an employee learns and creates is left behind if they switch jobs. A job may look more attractive to a potential employee if they know that their efforts will not stay within a “walled garden.” In other words, open source software and open standards are transferable skills.
- Your business can have more of a “vote” when it comes to the direction and features of the open source software that you use. Those who contribute the most to open source projects get the most say in what direction the project goes in and what features are added. Features that are important to your business can be added to the software that you use.
- You can claim that you are an open source contributor, not just a consumer. This can also communicate legitimacy and experience to potential clients.
These are just a few that I came up with. I would love to hear if anyone has additional benefits to add to this list.
