Archive for the 'Open Source' Category


Apache: Stripping/Remove the www from URLS

Wednesday, August 19th, 2009

For reasons I won’t go into, I wanted to force Apache to strip the www from the URLs. So if someone typed in http://www.abc.com, Apache would automatically send them to http://abc.com. First thing to do is make sure ModRewrite is enabled, once that’s done simply put the following in your VirtualHost configuration or in the associated .htaccess file:

Code:
RewriteEngine on
RewriteCond %{HTTP_HOST} ^www\.(.+)$
RewriteRule ^(.*)$ http://%1/$1 [R=301,L]

o’reilly: The GPL and Software as a Service

Wednesday, August 8th, 2007

I’ve never been a big fan of GPL. The license is too ambiguous and in certain cases may be open to interpretation. I was reading up on Sphinx and what it can do when it struck me: This license says nothing about using software as a service. A quick Google search confirmed my thought via a blog post by O’Reilly:

..that free software license requirements to release source code are all triggered by the act of distribution, and that web applications, which are not actually “distributed,” are therefore not bound by these licenses..

Tech Talk: Dojo JavaScript Toolkit slides

Thursday, March 1st, 2007

I’m giving a tech talk today at work on a JavaScript Toolkit called Dojo. I made the slides based off of the dojo.book documentation. I uploaded the slides to Zoho, you can see them below. Hit the button in the bottom corner to maximize the presentation.

YUI: Blog, Library, Patterns, Theater

Tuesday, February 27th, 2007

I’m blown away at how “right” Yahoo is doing it. All too often I see corporation doing Open Source, but releasing some early, un-commented, buggy piece of crap to the public, while keeping the corporate version under wraps. Yahoo released their next version of the YUI Library the other day, this says it all:

YUI was released internally at Yahoo! about six months before it was released for public use under a BSD license in February 2006. Although the internal and external versions of the library were identical, the way we built and distributed them was different and we managed those differences with separate versioning tracks. Today we’re merging the internal and external project versioning and reaffirming that the YUI you can download here is exactly the same YUI Library used all across Yahoo!. Hence, we’re retiring the old public version series (which had reached 0.12.2) and we’re unifying the versioning of this release at v2.2.0.

Aside from the YUI Library and Patterns, theirs great video tutorials from industry folks (YUI Theater), including a total of 10 videos by Douglas Crockford covering all aspects of JavaScript.

YUI Blog
YUI Library
YUI Design Patterns
YUI Theater

Friday wrap-up #2

Friday, October 20th, 2006

CASCON was running this week from Monday to Thursday. I didn’t realize this was a free conference for everyone, including people outside IBM. I saw a bunch of professors from McMaster also, some were giving talks.

I went to the Ruby on Rails workshop and it was going OK until one of the presenters starting comparing Ruby on Rails (RoR) to PHP. People need to get something straight: Ruby is the programming language and Rails is a framework. Comparing RoR to PHP isn’t fair, since PHP is the programming language with no framework. If you’re going to compare them, make sure your using some type of template engine like Smarty, etc.

Tuesday, Wednesday and Thursday I had a display at the Technology Showcase from 11:30am to 1:30pm, presenting WDSC and JWL. The experience was good, I met a lot of great people really interested in AJAX and JSF.

Doug Crockford is a smart guy, he’s a JavaScript guru and the creator of JSON. Earlier this year he wrote a paper describing JSONRequest, here’s the abstract:

XMLHttpRequest has a security model which is inadequate for supporting the next generation of web applications. JSONRequest is proposed as a new browser service that allows for two-way data exchange with any JSON data server without exposing users or organization to harm. It exchanges data between scripts on pages with JSON servers in the web. It is hoped that browser makers will build this feature into their products in order to enable the next advance in web application development.

It’s a good read and not a bad idea (though received a lot of criticism). There has also been heavy discussion about this on the Dojo mailing list. Doug’s personal website is filled with great JavaScript articles and resources – especially this article on objects in JavaScript.

I read Chapter 5 of Roy Fielding’s dissertation, which introduced REST or Representational State Transfer. REST is a lot like the Relational Database, conceptually its easy, but has the potential to revolutionize how we do certain things.

How To: Making a PHP REST client to call REST resources

Friday, October 20th, 2006

A lot of companies these days (including Amazon and Yahoo!) are exposing their web services in the form of REST resources. At a high level REST is pretty easy to understand, all you’re doing is exposing a web service in the form of a URL. Users can then query this URL, through HTTP methods like GET and POST. REST calls generally return some type of XML or Object Encoding like JSON.

An example would be Yahoo!’s Geocoding API, with the following URL:

Code:
http://api.local.yahoo.com/MapsService/V1/geocode?appid=YahooDemo&street=701+First+Street&city=Sunnyvale&state=CA

I would get:

Code:
<Result precision="address">
   <Latitude>37.416384</Latitude>
   <Longitude>-122.024853</Longitude>
   <Address>701 FIRST AVE</Address>
   <City>SUNNYVALE</City>
   <State>CA</State>
   <Zip>94089-1019</Zip>
   <Country>US</Country>
</Result>

So Yahoo! exposes the Geocode URL and allows you to query this resource using URL parameters like appid and street. Dynamically building your URL to query a given resource is OK, generally that’s what people do, like the following:

Code:
$base = 'http://xml.amazon.com/onca/xml3';
$query_string = "";

$params = array( 'ManufacturerSearch' => "O'Reilly",
    'mode'  => 'books',
    'sort'  => '+salesrank',
    'page'  => 1,
    'type'  => 'lite',
    'f'     => 'xml',
    't'     => 'trachtenberg-20' ,
    'dev-t' => 'XXXXXXXXXXXXXX' ,
);

foreach ($params as $key => $value) {
    $query_string .= "$key=" . urlencode($value) . "&";
}

$url = "$base?$query_string";
$output = file_get_contents($url);

The problem here, is that REST is meant to take advantage of HTTP methods GET, POST, PUT, DELETE, etc.. When people are showing examples which dynamically build queries and call file_get_contents, the average user doesn’t appreciate (understand) what type of request is being made. Do they care? Should they care? We’ll that’s another story. Eventually though, more intense REST resources will become widely available, and it will be critical the user (developer) understands if their making a POST or PUT request.

I came across a great PEAR package the other day called HTTP_REQUEST, which among many things supports GET/POST/HEAD/TRACE/PUT/DELETE, basic authentication, proxy, proxy authentication, SSL, file uploads and more. Using this package, I got started on a simple wrapper class called RESTclient, which gives intuitive support for making REST resource calls.

So if I was going to use RESTclient to call the Geocode API above, it would look like this:

Code:
<?php

require_once "RESTclient.php";

$rest = new RESTclient();

$inputs = array();
$inputs["appid"] = "YahooDemo";
$inputs["street"] = "701 First Street";
$inputs["city"] = "Sunnyvale";
$inputs["state"] = "CA";

$url = "http://api.local.yahoo.com/MapsService/V1/geocode/"
$rest->createRequest("$url","POST",$inputs);
$rest->sendRequest();
$output = $rest->getResponse();
echo $output;

?>

At this point, you might be thinking, who cares — what’s the difference between using a loop to dynamically generate the URL or RESTclient. There are lots of reasons, first off, I can easily call the Geocode resource again using another address just by changing:

Code:
$inputs["street"] = "1600 Amphitheatre Parkway";
$inputs["city"] = "Mountain View";

There was no need to re-generate the URL. Furthermore, I’m explicitly specifying a POST request. Just as easily I can make a PUT, DELETE, etc. request on a given resource by changing the createRequest method parameters.

The class below is RESTclient. Note, I put this together to prove a point, it still needs some work if you plan on using it.

Code:
<?php

require_once "HTTP/Request.php";

class RESTClient {

    private $root_url = "";
    private $curr_url = "";
    private $user_name = "";
    private $password = "";
    private $response = "";
    private $responseBody = "";
    private $req = null;

    public function __construct($root_url = "", $user_name = "", $password = "") {
        $this->root_url = $this->curr_url = $root_url;
        $this->user_name = $user_name;
        $this->password = $password;
        if ($root_url != "") {
            $this->createRequest("GET");
            $this->sendRequest();
        }
        return true;
    }

    public function createRequest($url, $method, $arr = null) {
        $this->curr_url = $url;
        $this->req =& new HTTP_Request($url);
        if ($this->user_name != "" && $this->password != "") {
           $this->req->setBasicAuth($this->user_name, $this->password);
        }        

        switch($method) {
            case "GET":
                $this->req->setMethod(HTTP_REQUEST_METHOD_GET);
                break;
            case "POST":
                $this->req->setMethod(HTTP_REQUEST_METHOD_POST);
                $this->addPostData($arr);
                break;
            case "PUT":
                $this->req->setMethod(HTTP_REQUEST_METHOD_PUT);
                // to-do
                break;
            case "DELETE":
                $this->req->setMethod(HTTP_REQUEST_METHOD_DELETE);
                // to-do
                break;
        }
    }

    private function addPostData($arr) {
        if ($arr != null) {
            foreach ($arr as $key => $value) {
                $this->req->addPostData($key, $value);
            }
        }
    }

    public function sendRequest() {
        $this->response = $this->req->sendRequest();

        if (PEAR::isError($this->response)) {
            echo $this->response->getMessage();
            die();
        } else {
            $this->responseBody = $this->req->getResponseBody();
        }
    }

    public function getResponse() {
        return $this->responseBody;
    }

}
?>

How to: Building dynamic PHP objects and URL decoding example

Friday, October 6th, 2006

PHP is a powerful programming language; with every release I’m amazed with the new power and functionality. The ability to build dynamic objects (the way I’ll describe) I believe was introduced as of PHP 5. In any case, this is good stuff. There are lots of reasons why you would want to create a dynamic object, in my example below; you’ll see how to create a dynamic object of the URL query parameters.

At the heart of building dynamic PHP objects are the PHP Magic Methods. From the PHP manual:

The function names __construct, __destruct (see Constructors and Destructors), __call, __get, __set, __isset, __unset (see Overloading), __sleep, __wakeup, __toString, __set_state, __clone and __autoload are magical in PHP classes. You cannot have functions with these names in any of your classes unless you want the magic functionality associated with them.

Magic methods get called automatically through the parser when certain events occur. For example, just before you transition pages all objects you’ve created will call their respective __sleep methods. Most likely you wouldn’t have this method defined, so nothing would happen.

So now lets look at what happens when a certain method (or variable) of a given PHP object is called. Take the following code as an example:

Code:
$x = new obj();
$x->method1();
$x->var1;

When a method of a given object is called (like method1) the first thing the parser does is look for the associated name in the instance of the object. If the method is found, then the parser gives control to the method. If the method is not found, then the __call function is called with the function name and input values as a parameter. If this function returns true, then the object will return successfully. If a __call function does not exist, the parser will check the parent class (if exists) and so forth.

Similarly, if a variable of an object is requested (like var1) the parser looks in the object for a variable with that name. If a variable does not exist, the __get method is called with the name of the variable as a parameter, and so forth.

You should be able to see how we can now simulate (fake) the existence of methods and variables by using these magic methods. The code below shows the parent class G_Dynamic. This class would be the parent to specific subclasses that would require dynamic method/variable access.

Code:
<?php

/*  */

/**
 *
 * PHP versions 5.1.4
 *
 * George A. Papayiannis
 *
 * This class provides the magic functions needed to create
 * a dynamic object.  Subclasses would extend this object
 * and call the constructor with a parsed array.  See
 * g_url_decode.class.php for an example of creating a
 * dynamic object from the URL query string.
 *
 */

/**
 * Class definition
 */

class G_Dynamic {

    private $param = array();

    public function __construct($init) {
        $this->param = $init;
    }

    private function __get($name) {
        if (isset($this->param[$name])) {
            $res = $this->param[$name];
        } else {
            $res = false;
        }
        return $res;
    }

    private function __set($name, $val) {
        if (isset($this->param[$name])) {
            $this->param[$name] = $val;
            $res = true;
        } else {
            $res = false;
        }
        return $res;
    }

    private function __isset($name) {
        return isset($this->param[$name]);
    }

    private function __unset($name) {
        unset($this->param[$name]);
    }

    private function __call($name, $var) {
        // add code to simulate function call
        // return TRUE for success
    }

}

?>

As an example, I created a subclass to G_Dynamic called G_URL_Decode. This class takes the URL query string as input, parses it into an array and calls the parents (G_Dynamic) constructor. The code for G_URL_Decode is below:

Code:
<?php

/*  */

/**
 *
 * PHP versions 5.1.4
 *
 * George A. Papayiannis
 *
 * This class extends the G_Dynamic class to create a
 * dynamic object of the URL query string.  In another
 * file, you would have:
 *
 * require_once "g_url_decode.class.php";
 * $x = new G_URL_Decode($_SERVER['QUERY_STRING']);
 *
 * then you could have $x->(url param name) to access
 *
 */

require_once "g_dynamic.class.php";

/**
 * Class definition
 */

class G_URL_Decode extends G_Dynamic {

    private $queryParam = array();

    public function __construct($qs) {
         parent::__construct($this->parseURL($qs));
    }

    public function getQueryParam() {
        return $this->queryParam;
    }

    private function parseURL($qs) {
        $this->queryParam = array();
        $qs_parsed = explode("&", $qs);
		foreach ($qs_parsed as $value) {
			$paramVal = explode("=",$value);
			if (array_key_exists(1,$paramVal)) {
				$this->queryParam[htmlspecialchars(urldecode($paramVal[0]))] = htmlspecialchars(urldecode($paramVal[1]));
			}
		}
		return $this->queryParam;
    }
}

?>

Once the URL query string is successfully parsed, you can access the parameter names through the object. The code to bring it all together is below.

Code:
<?php

require_once "g_url_decode.class.php";
$x = new G_URL_Decode($_SERVER['QUERY_STRING']);
echo $x->var1;

?>

Using this as a base, you should be able to build some pretty cool dynamic objects.
Click here to download the source.

SemCodeFix: A plugin to display preformatted code in WordPress

Saturday, September 16th, 2006

SemCodeFix is a WordPress plugin I made to display preformatted code correctly. This plugin can display any type of code, html, text, scripts, etc. Using the plugin is easy, just wrap your text in a code tag from within the WordPress editor. Here’s an example of what it would look like. The code below is Python, its a solution to the Eight queens puzzle.

Code:
def n_queens(n, width):
    if n == 0:
        return [[]] # one solution, the empty list
    else:
        return add_queen(n-1, width, n_queens(n-1, width))

def add_queen(new_row, width, previous_solutions):
    solutions = []
    for sol in previous_solutions:
        for new_col in range(width):
            if safe_queen(new_row, new_col, sol):
                solutions.append(sol + [new_col])
    return solutions

def safe_queen(new_row, new_col, sol):
    for row in range(new_row):
        if (sol[row] == new_col or  # same column clash
            sol[row] + row == new_col + new_row or  # diagonal clash
            sol[row] - row == new_col - new_row):   # other diagonal
                return 0
    return 1

for sol in n_queens(8, 8):
   print sol

To activate/use this plugin, do the following:

1. Place the plugin file in the plugin directory of your WordPress installation and activate it.
2. Copy and paste the CSS into your local.css file of your theme’s directory.
3. Depending on your theme, your might want to change the width value in the div.code_child css style.
4. Any code you have, just wrap it in a code tag from within the editor.

When installed, the plugin will override the native code styles of your theme and display output as above.
Download the plugin file
Download the CSS file

Good luck

Comet: Life after AJAX

Tuesday, August 8th, 2006

There is no doubt that AJAX is a brilliant idea, which has pushed web development to a new level. That said, the framework has many limitations, and a lot of big time names in the open source industry (Alex Russel being one of them) have taken notice. People that don’t understand Comet call it “disgruntled AJAX developers who went off on their own”. The reality is, that a server-side event driven model for web development is needed. The catch? A long-lived static connection from the client-side (browser) to the server is needed. For example, this event driven server-side model, means that the server can now tell the client to refresh a panel on demand (without the client making a request).

On Sunday, the Dojo Foundation announced Cometd as a new Dojo project.

Cometd is a scalable HTTP-based event routing bus that uses a push technology pattern known as Comet.

Dojo: A glimpse into the future of web development

Thursday, August 3rd, 2006

Update (Aug. 17 2006): The more I use Dojo, the more impressed I am with what is being done. The entire project has so much attention to detail. I just spent a little while looking at dojo.io.* and am blown away at this easy to use, transparent approach to AJAX.

That’s a powerful title, will it come true? Who knows. At this moment and time, at version 0.3, Dojo is insanely impressive.
So the first question that most people will have is: What is Dojo?

Dojo is the Open Source Javascript toolkit that makes professional web development better, easier, and faster

A little more detail:

Dojo is an Open Source DHTML toolkit written in JavaScript. It builds on several contributed code bases (nWidgets, Burstlib, f(m)), which is why we refer to it sometimes as a “unified” toolkit. Dojo aims to solve some long-standing historical problems with DHTML which prevented mass adoption of dynamic web application development.

Dojo allows you to easily build dynamic capabilities into web pages and any other environment that supports JavaScript sanely. You can use the components that Dojo provides to make your web sites more useable, responsive, and functional. With Dojo you can build degradeable user interfaces more easily, prototype interactive widgets quickly, and animate transitions. You can use the lower-level APIs and compatibility layers from Dojo to write portable JavaScript and simplify complex scripts. Dojo’s event system, I/O APIs, and generic language enhancement form the basis of a powerful programming environment

I hear people say “Dojo, that’s the AJAX framework”. Sure, Dojo is about asynchronous interaction, but that’s only a part of the story. The problem with JavaScript is that it blew up way too fast. It’s a powerful programming language, but lacks the subtleties, which would make it easy to develop large-scale JavaScript applications. I doubt in the mid 90s Netscape envisioned JavaScript the way its used today. In 2002, Doug Crockford got fed up and made JSLint:

When C was a young programming language, there were several common programming errors that were not caught by the primitive compilers, so an accessory program called lint was developed which would scan a source file, looking for problems. As the language matured, the definition of the language was strengthened to eliminate some insecurities, and compilers got better at issuing warnings. lint is no longer needed.

JavaScript is a young language. It was originally intended to do small tasks in webpages, tasks for which Java was too heavy and clumsy. But JavaScript is a very capable language, and it is now being used in larger projects. Many of the features that were intended to make the language easy to use are troublesome for larger projects. A lint for JavaScript is needed: JSLint, a JavaScript syntax checker and validator.

The good folks at Dojo have taken this a massive step further, put very gently:

dojo.lang.* contains wrappers for common idioms. It doesn’t provide replacements for language constructs. We only provide functions that provide value-added above the standard javascript routines, or functions that mask browser incompatibilites, etc.

The reality is, an amazing, transparent, useful framework has been (is being) developed, which will give the Web developer power they’ve only dreamt of. Were talking proper class constructs, inheritance, the ability to override methods, and much more.

In total there is the Dojo Infrastructure (fundamental behaviors), General purpose libraries (String manip., DOM manip., etc…), Data Structures (Dictionary, ArrayList, Queue, etc..), Web I/O (RPC, JSON, etc.), Visual Web (animations, graphics, etc.), Math and Cryptogrpahy (speaks for itself.. clientside Crypto, like Meebo) and a great Widget library.

What kind of widgets are we looking at? Here is a taste of what you can expect:

FisheyeList – hover over the menu at the top…
Popup Dialogs – click the links on the top left…
Floating Pane – drag them, close them.. the world is your oyster
Inline Edit Box – just like Flikr, click the title and text…

All this, and their only in version 0.3. Give it a try: dojotoolkit.com — be warned documentation to the specifics of the API is sparse.

How To: Bridging the Gap – Integrating PHP and Java

Thursday, July 20th, 2006

I set out a couple days ago, to see how I could use an existing Java class or Jar within a PHP application. From what I found there are essentially two ways of going about this. The first is to integrate Java support directly into PHP using a regular HTTP server, while the second was to deploy a custom made WAR file into a J2EE container like Tomcat.

One thing for sure in this world: PHP programmers do not want the J2EE world forced upon them. The solution for me was obvious: integrate Java support directly into PHP. I had a couple options to tackle this. I thought about writing my own library, which would use RPC or JNI calls to connect with the existing JAR file, or perhaps use an existing PECL package, but after a little research the best option was to use the open source project PHP/Java Bridge. The project had received rave reviews and in tests destroyed its competition in performance; by using it own custom protocol to facilitate data transfer.

Installation was also a breeze. Assuming you have Apache and PHP already installed, copy the appropriate .dll file from the JavaBrdige.war into extension_dir (as defined in php.ini). For convince rename it to php_java.dll.

for PHP >= 4.3.4 use php-4-java-x86-windows.dll
for PHP >= 5.0.0 use php-5.0-java-x86-windows.dll
for PHP >= 5.1.0 use java-x86-windows.dll

Next, copy JavaBridge.jar from the War file also, into the extension_dir directory. Then open the php.ini file and add the new extension, i.e.

extension=php_java.dll

That’s it, whatever jar file your going to be using, place it in the lib folder of your php installation. Restart the server and you should be good to go.

k-means and EM clustering algorithms

Sunday, April 16th, 2006

The final data mining assignment (which was due in the middle of exams) was to implement the k-means and EM algorithms in C. These are two pretty simple clustering algorithms, with k-means (or renditions of k-means) used in industry all the time. Both algorithms work in 2-dimensions and take an input file of data points separated by a space.

K-means works as follow:

  • Place K points into the space represented by the objects that are being clustered. These points represent initial group centroids.
  • Assign each object to the group that has the closest centroid.
  • When all objects have been assigned, recalculate the positions of the K centroids.
  • Repeat Steps 2 and 3 until the centroids no longer move. This produces a separation of the objects into groups from which the metric to be minimized can be calculated.

      The EM algorithm is a bit more complicated, but has generally the same idea:

      em

      Since this was in the middle of exams, I wrote both solutions (code) in one night (7pm to 3am), so no guarantee whatsoever. Take a look; if you’d change anything let me know. The code is licensed under GPL v2.

    Thesis Design Project: Robot Java Code

    Monday, April 3rd, 2006

    One of my main jobs when working on this project, was to write the code which would control the Robot.
    The code is written in Java as our Robot’s OS was leJOS.

    Features of the code include:

    • A single control loop (as opposed to multiple threads and listeners)
    • A great ‘stay straight’ algorithm which keeps the robot centered in the network, through 2 light sensors
    • Transmission to and from the host component for tasks and logging information
    • A task driven control structure

    You can download the code here. To learn more about our final product go here.

    Compiling VPN client on Linux

    Tuesday, January 10th, 2006

    Just in case anyone in the future has a similar problem — The installation requirements for compiling the Cisco VPN Linux Client says to download the Kernel Source. This won’t work, download the Kernel Source Headers.

    Cygwin to Ubuntu

    Monday, January 9th, 2006

    I finally made the move from Cygwin (Windows) to Linux. I’m working on getting a home-built server running, and the first step was getting a mirror image (of the future server) running on my laptop. My distro of choice is Ubuntu. The installation was easy, but I had a few problems getting the video card and my wireless card going. Everything is running smoothly now.. Next step: install Apache, PHP, MySQL, etc.. on my laptop, exactly as I would have it on the server.

    My laptop is 4 years old, a Dell Inspiron 1100, if anyone has the same problem getting their video card to work, just do the following:

    1. type ‘gedit /etc/X11/xorg.conf’
    2. Add the following 2 lines (inside of the #)

    Code:
    Section "Monitor"
    Identifier "Generic Monitor"
    Option "DPMS"
    # add
    HorizSync 31.5-48.5
    VertRefresh 59-75
    # end add
    EndSection

    Once I have the server done, I’ll be installing Ubuntu-Server on the server. I’ll talk about that when it happens.

    IBM RSE to go open source soon

    Friday, December 9th, 2005

    I’m excited to have the IBM Remote Systems Explorer (RSE) go open source soon. I have some cool ideas of how I could use it in the short term. One would be using it as a possible interface to the next version of the extractor robot (for thesis design project).

    From the November 11th meeting notes, it looks like it might be out sometime in December:

    RSE Status:

    Making some progress but sill some obstacles; looking better, but not quite there yet, hopefully make it till the next meeting (3 weeks)

    That would be perfect, I could play with it over the holidays and see if it would work with the RCX brick.

    AJAX: Cleaning product, city, web paradigm

    Monday, December 5th, 2005
    ajax

    It blows my mind how crazy some people are for AJAX these days. It’s consistently one of Technorati’s most search terms, and even the Ajax page for Wikipedia has the following:

    This article or section has or is prone to spam, that is, HTML links added only to promote a site or product.
    Following Wikipedia:External links, please help Wikipedia by removing any commercial links on sight. Please retain this notice if necessary, and report rampant spamming as per instructions at Wikipedia:Spam.

    The word/term Ajax could be used for a lot of thing: a marketed cleaning product, a city, a web paradigm.. I wonder how long it will take, till the general public hears the word Ajax and thinks of the web instead of a cleaning product? Probably never, in any case: some people love Web 2.0, some people hate it.

    ApacheCon Europe Presentation

    Tuesday, November 15th, 2005

    Most likely anyone who has ever used Apache Web Server, at one point or another, has said “how in the world was I supposed to have known that??” in respect to httpd’s inconsistencies.

    Rich Bowen had a hilarious presentation at ApacheCon Europe joking about how he Hate the Apache Web Server.

    Mozilla to attack when Vista launches?

    Saturday, October 22nd, 2005

    FireFox recently passed the 100M download mark, only 6 months after they reached 50M. I guess the real question is how many people actually use the browser regularly? On average, say each person has 2 computers (work and home), format twice a year… that 100M could be lower.

    …(FireFox) may see a big fall after the leader in the browser market Microsoft’s launches its Windows Vista operating system … alongside the newer version of the Internet Explorer. A Gartner analyst even suggested, “Much will depend on how Microsoft ties Internet Explorer to its big releases next year”.

    I wouldn’t be surprised if whenever Vista launches, Mozilla initiates their largest marketing effort to date. Over the summer, the ‘for profit’ arm of Mozilla was formed — see Mozilla re-Structure — and I’m sure one of their goals is to make sure FireFox grows post Vista. Furthermore, large companies in the past have pledged large amount of money to Mozilla, including AOL back in 2003. What I want to see is IBM and Google publicly inject a huge amount of money for a total Mozilla marketing effort.

    Below is the 2 year Alexa traffic chart of mozilla.org — growth is obvious. Below that (un-fair) comparison with microsoft.com

    Mozilla Alexa

    Mozilla compare MS Alexa

    High hopes: US State plans switch to open source

    Friday, September 2nd, 2005

    I personally believe the open source move is a great idea, but seriously though, people have to choose their battles wisely. It’s important not to get caught up in the hype and love of free software.

    Microsoft has come this far on the average person. People love simplicity, reoccurring themes and ease of use. When dealing with Microsoft Word, you know that if you write your Master’s Thesis in a DOC format, and then send it to Kinkos to print, its going to print exactly the same as it would on your home printer. Can the same be said if you used Word and Kinkos used OpenOffice? What if your Word file had complicated macro’s for TOC, heading, figures, footnotes, etc.?

    So I was surprised when I read the Forbes article saying:

    The state of Massachusetts is proposing to make all its workers stop using Microsoft’s Word, Excel and other desktop software applications and switch to open source software…

    My immediate reaction was: Good luck with that, it would be nice, but I don’t see it surviving. It’s another example of people getting caught up in the hype of open source and it application to the average person.