Open Source

Printing 42 - A not so straightforward Boo way

Vagmi Mudumbai — Tue, 24 Jan 2006 13:30:00 GMT

I was recently working with Reflection and Boo and thought this was funny. Hey.. nobody told life is simple right. So, here it goes. :-)

i as int
i=i.GetType().GetMethod("Parse",[typeof(string)].ToArray(typeof(System.Type))).Invoke(null,["42"].ToArray())
print "Answer to the question of life, universe and everything is ", i

GPLv3 draft posted

Vagmi Mudumbai — Tue, 17 Jan 2006 22:59:00 GMT

The new GPLv3 draft has been posted for discussion. The Rationale Document explains the changes.

Lawrence Lessig on Transparent Creativity

Vagmi Mudumbai — Tue, 18 Oct 2005 20:24:00 GMT

I found this flash presentation while I was browsing the web today. It was Lawrence Lessig's address at OSCON 2002. An extremely interesting presentation.

Multi Platform versus Cross Platform

Vagmi Mudumbai — Fri, 07 Oct 2005 20:22:00 GMT

I have lately been pondering over methods to deploy cross platform products. I investigated certain options like InstallShield's Universal Project and ZeroG's InstallAnywhere. But to tell the truth, it goes against the philosophy of installation. They rely on the presence of the right version of JRE. Some installations also package the native versions of JRE along with the installation package. This is quite an overhead. Other products use their custom homegrown installers. As most of the setup developers and administrators know, homegrown installers are a disaster waiting to happen. A good installation technology should do the following.

Installation - This is the easy part.
Rollback in case of failure
Support for dependency and conflict resolution.
Support for transactional install/uninstall operations. This is very important for the integrity of the system.
Support for upgrades.
Heal installed applications.

Creating a custom installation technology with all these features is difficult if not impossible. Also it is an investment that is not required when you can reuse the wheel. Each of the operating systems or the platform targeted have a native installation technology which support all of the above points in some way or the other. Most of these cross platform applications are deployed on Windows, Linux or Solaris. Windows has the Windows Installer a.k.a MSI package format to keep an inventory of software that is installed in an extremely fine granular level. Linux has RPM and DEB formats which deal with packages at a more coarse scale than Windows Installer but have excellent dependency and conflict resolution. Solaris has its native PKG format to install packages.

So instead of a cross-platform installation program, we could have a cross platform tool to create multiple installation packages for multiple platforms. One of the biggest problems working in this direction would be that the setup engineer should have a knowledge of all the platforms that he is packing the application for. This is usually not a easy job. For instance, I could handle Windows MSI and Linux's RPM & DEB files but would be a completely lost on a Solaris platform.

The biggest challenge would also be the fact that the customization scripts and custom actions would need to be coded by the setup engineer for each platform or package format. But this is a small price to pay for the amount of flexibility that can be achieved. The software deployment becomes a breeze and would significantly lower the (holy grail of three letter acronyms) TCO.

Ruby/Rake and Python Decorators

Vagmi Mudumbai — Thu, 01 Sep 2005 17:40:00 GMT

I had been experimenting with Ruby/Rake. I took a little while for me to get adjusted to Ruby's syntax. I love closures in Ruby and their effective use in Rake. I was trying if I could do the same in Python. As always, I came up with a very shabby code as the first attempt.

#run target.py
# the global dict to store targets
targets={}
#defining and adding a target
class Target:
    def __init__(self,name='',dependencies=[],fn=None):
        self.name=name
        self.dependencies=dependencies
        self.fn=fn
        self.done=False
        self.success=False

    def run(self):
        if(not self.done):
            self.success=self.fn(self)
            self.done=True
        return self.success

    def describetarget(self):
        print self.fn.__doc__

def addtarget(name,dependencies,callable):
    objtarget=Target(name,dependencies,callable)
    targets[name]=objtarget

# now to add the actual target

def sayHello(target):
    '''Prints hello world with the calling targets' name'''
    print "hello world from " + target.name
    return True
addtarget('sayhello',[],sayHello)

#run the target
targets['sayhello'].run()

As you can clearly see, you would have to first define the function and add it later as the target. For simplicity sake have not written the logic of constructing the dependency tree. You can see that this is nowhere close to writing the same code in Ruby. Consider the following.

Python Code:

def sayHello(target):
    '''Prints hello world with the calling targets' name'''
    print "hello world from " + target.name
    return True
addtarget('sayhello',[],sayHello)

Versus

Rake Code:

task :mytask do |t|
print 'hello world ' + t.name
end

The magic of ruby code is in closures. Python does support closures. Python 2.4 also has a new feature called decorators which can do the same thing. This is what I did in Python using decorators.

#runtargetwithdecorator.py
#global dict to store targets
targets={}

#the target class
class Target:
    def __init__(self,name='',dependencies=[],fn=None):
        self.name=name
        self.dependencies=dependencies
        self.fn=fn
        self.done=False
        self.success=False

    def run(self):
        if(not self.done):
            self.success=self.fn(self)
            self.done=True
        return self.success

#the target decorator function

def target(name,dependencies=[]):
    def decorator(f):
        mytarget=Target(name,dependencies,f)
        targets[name]=mytarget
        return f
    return decorator

#implementing the decorator
@target('mytarget')
def MyFunction(target):
    print "hello world", target.name
    return True

targets['mytarget'].run()

Now consider the following.

Python code:

@target('mytarget')
def MyFunction(target):
print "hello world", target.name
return True

versus

Ruby code:

task :mytask do |t|
print 'hello world ' + t.name
end

Now the python code is a lot more easlier to read than its counterpart in Ruby. Python may not be an effective DSL for build languages but is definitely a lot easier to read and understand than Ruby's code. But you cannot have a empty defaults target defined in python. You should have a valid callable after the @decorator. For example, to my knowledge, you cannot write the following code in python without the following function.

@target('default',['mytarget1','mytarget2'])
def somefn(target):
pass

But you can write the following code in ruby without any closure method.

task :default => [:mytask1,:mytask2]

In spite of Rake's simplicity, I still would prefer writing Python code. I guess it is just my personal preference. No offence to Rake fans. :-)

The importance of Free and Liberal Open Source Software (FLOSS) in the Indian context

Vagmi Mudumbai — Tue, 30 Aug 2005 20:45:00 GMT

There exists a lot of literature written on Free and Liberal Open Source Software(GNU/FSF). This is what I feel about it. I had recently been to a school to give an introduction about computers to some kids in a village near Pondicherry. I had access to a laptop and showed them a quick presentation on the basics of computers. I was aware of the fact that the school syllabus has Microsoft Windows as the primary platform for education. Most kids think paint is cool. What would they say if they saw GIMP? But the government has to realize that providing a computer and upgrading the license of the operating system is a costly business. Most of the schools in India run on a shoe string budget. Let us do the math now.

Number of students for a class (at least)	30
Number of client licenses to be purchased if the computer is shared by 3 users	10
Cost of a computer (approx)	Rs. 10,000/-
Cost of a Microsoft Windows client license (approx)	Rs. 2,500/-
Cost of a Microsoft Windows Server range operating system	Rs. 40,000/-
Total cost for client operating system licenses	Rs. 25,000/-
Total cost of the workstations (hardware)	Rs. 1,00,000/-
Cost of the server hardware (basic p4 based desktop to act as a database server/Web Server)	Rs. 30,000/-
Total cost of setting up 10 terminals with 1 server	Rs. 1,95,000/-

I have not included the cost of buying software like Microsoft Visual Studio .NET 2003 and Microsoft SQL Server, which would each cost about 35,000 and 45,000 approximately. Please let me know if my figures are wrong. And the SQL Server is for 45,000 is only a standard 5-client edition. Also there exists a problem with upgrades. You would have to pay for them too. You would need to get two licenses which would mean a catastrophic cost for a simple school to setup. The common solution that various schools adopt is to pirate the software. This is much more rampant in the schools in the private sector. A crackdown on such schools would put most of the schools out of business. The moment you open a new school/college you open up a software piracy den and promote criminals. Let us look at the figures for Linux.

Number of students for a class (at least)	30
Number of client licenses to be purchased if the computer is shared by 3 users	10
Cost of a computer (approx)	Rs. 10,000/-
Cost of a Microsoft Windows client license (approx)	Rs. 0/-
Cost of a Microsoft Windows Server range operating system	Rs. 0/-
Total cost for client operating system licenses	Rs. 0/-
Total cost of the workstations (hardware)	Rs. 1,00,000/-
Cost of the server hardware (basic p4 based desktop to act as a database server/Web Server)	Rs. 30,000/-
Total cost of setting up 10 terminals with 1 server	Rs. 1,30,000/-

As it is clearly seen, it is important for all the schools in India to adopt Free and Liberal Open Source Software. This step would mean the following advantages for the Indian society.

The cost of setting up new computer labs is significantly lowered.
Students will gain the ability to produce software on open source platforms.
Projects targetted at open source platform can serve the Indian Society.
This will free the small businesses from the requirement of purchasing pricey software. They could use open source software built by our future software professionals.
Open Source Software engineers in my belief have a better understanding of the underlying technology and can really benefit from the community.

Necessity is the mother of invention. As more and more people adopt open source software, I am sure that they in turn will create a need for better software. I have been using Linux on and off for the past several years and have seen it progress in leaps and bounds. I would strongly suggest open source operating systems like FreeBSD or Linux as the operating systems. They have a host of open source products to suffice every need in the closed source world. I do agree that there are open source products available in the closed source platform that are on par with their commercial counterparts. For example, SharpDevelop would suffice the need of any normal C# programmer who has not been pampered with Visual Studio .NET 2003 features. But on the other hand you have Eclipse which would seem VS.NET 2003 seem like a baby. MySQL competes with Microsoft SQL Server in the DB Server arena. PHP can serve as a commendable alternative to ASP and ASP.NET. Apache Web Server gives IIS a run for their money in the Web Server segment. Java and Mono provide solid cross platform application frameworks. Even though Java is not strictly open source, its free availability on open source platform makes it a lucrative option. Apart for these compilable languages, Python and Ruby offer a quick application development cycle which is ideal for developing small business tools.

It is now time for the educational institutions in India to decide if they still want to pay a huge sum or indulge in criminal practices to learn/teach software or adopt the clean and relatively hassle free path of Open Source software to produce better software engineers.