Well, the conversion back to PCLOS went a lot smoother than I thought, thanks to a remaster of PCLOS dubbed "TinyMe". TinyMe is a very lightweight version of PCLOS, using Openbox as a window manager, PCManFM as file manager, and LXDE to round off the desktop experience. With TinyMe, I no longer had to fiddle with the GRUB boot options to make sure bootup actually went beyond GRUB(as it did with PCLOS 2007). So now I have a fairly lightweight environment, but I can also play SL thanks to Synaptic. But again, I'm not giving up on SliTaz. I may decide to buy an Eee PC laptop for my birthday coming up and plop SliTaz on it until they do get Nvidia packages made.

]]>

Recently on DistroWatch I heard about SliTaz GNU/Linux, a new distro that may very well be the smallest desktop distro ever(a 25MB LiveCD image). I had the chance to try out this little wonder on my PC, since PCLinuxOS updates weren't coming down the pipe for a long while(that's changed now), and I'm pleasantly surprised with it.

Overview

Currently Slitaz comes in two forms: Stable and Cooking. The Stable release features the JWM window manager, emelfm2 file manager, Firefox, AlsaPlayer, mtPaint, LightTPD web server, SQLite, and many other packages via the simple but effective package manager tazpkg. The Cooking release is what will eventually become the next stable release, replacing JWM with the much better Openbox window manager, PCManFM file manager, HardInfo system information tool, SearchMonkey and more tools to come. Plus you can create your own customized version of SliTaz using the Tazlito LiveCD creation tool.

I am actually writing up this post in SliTaz right now, which says a lot about how I'm really liking this little powerhouse distro. The only thing keeping me from permanently switching to SliTaz is that there are no proper Nvidia or ATI 3D acceleration packages available yet, so I could play Second Life(TM). But then again SliTaz is meant for use on old hardware, so I could be putting an unrealistic expectation on it. I will be sticking with SliTaz for a while, then migrate back to PCLOS(which now sadly looks quite bloated for my needs) as I need to keep up with my store and friends in SL.

]]>

Recently, my desktop PC's power supply had burned out. While I could easily have just bought a new power supply for $30(at most), I had decided to buy a new, better PC. What I got was a dual-core(2 Pentium D processors) monster in a crazy XBlade case for $500. It came with Windows XP Pro pre-installed, but I quickly noticed something about it: it wasn't a legit copy! How did I know? First, it had Norton Antivirus 2005. And, I found a little application called "KEYGEN!!!" hidden away in the Recycle Bin.

So, being a lawful citizen I decided to wipe out XP and install Linux on this bad boy(I just paid $500 and I'm not going to pay over $100 more just to "get right with Microsoft"). Sadly, the only Ubuntu disc I had was a Gutsy beta disc and it just would not install. I did however have a copy of PCLinuxOS 2007 ready to go on a Linux Format DVD I had(Note to self: must renew subscription). The Live session ran great, and the installation process was painless. But the installation wasn't really done after first boot. Once KDE started up, a little package update applet told me I had over 400 updates available. Yikes! But I expected that, so I proceeded to use Synaptic(yes, PCLOS is an RPM-based distro, but it uses apt-get/Synaptic instead) to install the updates.

After the updates were done, I had considered the installation complete and set up PCLOS for my specific needs. In part 2, I will talk about what I did customizing PCLOS and why I'm seriously considering making it my distro of choice for a while.

]]>

Yes folks, Python is truly a programmer's goldmine. Today we're going to do something Web 2.0-worthy with Python. We're going to create a server written in Python. But not just any old server. We're going to create an XML-RPC server, and we'll also write up a tiny client for it as well to demonstrate how surprisingly simple it is to build a server.

First, let's write up the server itself. Let's call this file "xmlrpc_server.py":

#!/usr/bin/env python

import SimpleXMLRPCServer
#set server address(local here)
servAddr=("localhost",8080)
#define server functions and instances here
def areaSquare(length):
        return length*length

def areaRectangle(length,width):
        return length*width

def areaCircle(radius):
        return 3.14*(radius*radius)

class MyFuncs:
        def say(self,line):
                return "#"+line+"#"

#create the server object
server=SimpleXMLRPCServer.SimpleXMLRPCServer(servAddr)
funclist=(areaSquare,areaRectangle,areaCircle)
#register functions
for eachfunc in funclist:
        server.register_function(eachfunc)
#register instance
server.register_instance(MyFuncs())
server.register_introspection_functions()
#start serving
server.serve_forever()

To start up this little server, type "python ./xmlrpc_server.py &" on the command-line. Now, let's write a little demo client to show that we can actually use the server. This file will be called "xmlrpc_client.py":

#!/usr/bin/env python

import xmlrpclib
#connect to a server
servAddr="http://localhost:8080"

s=xmlrpclib.ServerProxy(servAddr)
#list available server methods
for m in s.system.listMethods():
        print m
#call server methods
print "Areas:"
print "Square:",s.areaSquare(5)
print "Rectangle:",s.areaRectangle(2,6)
print "Circle:",s.areaCircle(5)
print s.say("E=m(c*c)")

Simply run "python ./xmlrpc_client.py", and you'll see that we are actually using functions stored remotely on the server. Pretty cool, right? No? Well, you haven't seen anything yet. You see, this XML-RPC stuff can be used within web services, which shockingly includes scripted objects within Second Life. With XML-RPC you can create objects networked together to do things that would be difficult, slow, or plain impossible to implement. I'll get more into this in my next post.

]]>

In case you didn't know, for almost 1 and 1/2 years I have been addicted to one MMOG: Second Life. What separates SL from other games such as There, World of Warcaft and others is that whatever you create within SL, you own it and therefore can sell it. This has engendered many in-world businesses and business models to flourish, including open source. Even I've gotten into the business act.

I've opened up a store on the newly created sim Ama Gi(which is ancient Sumerian for "freedom"), an island sim dedicated to the ideals and promotion of FOSS and free culture. My store is called simply "Antonius Misfit's Open Source Shop", where I sell some skyboxes, but mainly scripted "laptop" computers(all open source, of course). My latest creation is something still in development, but I'm very proud of it as it is my first product from scratch. It's a GPLv3-licensed build packager and rezzer I call "Apt-Rez". Of course, Apt-Rez isn't the only product of it's kind available(such as Rez-Foo and Rez-Faux), but I feel it perfectly serves as not only a ready-to-use solution for builders, but also as a learning aid for budding LSL scripters or a starting point to roll your own rezzer. Plus, Apt-Rez is also available for purchase either at my shop or on SL Exchange for a nominal price(Yes, the GPL says it's perfectly acceptable to sell your own open source items as long as the source is freely attainable, something that apparently even some open source developers haven't grokked yet).

]]>

In my last entry, I introduced Python as a quick and easy way to create GUI programs for Ubuntu. However, Python has a super-handy module for creating your own command-line interfaces, known simply as cmd. Specifically, cmd contains a minimal class representing a command-line shell, called Cmd. To create your own shells, you must subclass cmd.Cmd and add your own functionality there. Here's a minimal example of how to create a command-line shell wth Python:

#!/usr/bin/env python

import os,sys,cmd,shlex,readline

class Shell(cmd.Cmd):
        def __init__(self,intro="Welcome to Shell):
                cmd.Cmd.__init__(self,intro)
        def do_prompt(self,line):
                "Set the command prompt"
                self.promptbackup="(Cmd) "
                if line=="":
                        self.prompt=self.promptbackup
                else:
                        self.prompt=line
        do_man=do_help
        def do_exit(self,line):
                "Exit Shell"
                return True

if __name__=="__main__":
        Shell().cmdloop()

As you can see, it's a fairly trivial affair. Actual commands are implemented as methods that begin with "do_". Exiting the shell requires a method that returns True. You can even create scripts for your shell, just like with any standard *nix shell or Windows batch file.

]]>

Ever since Ubuntu Linux arrived on the scene three years ago, it has become the most popular distribution in the world, and perhaps the one to bring Linux to the completely non-geek masses. But even though Ubuntu seems to be a desktop-only distribution at first glance, there's a lot of programming power built-in even before the first time the "Add/Remove..." app or Synaptic is run. Here's the rundown of Ubuntu's three hidden programming gems:

GUI programming with Python
While many open source programs are written in C or C++, those languages are too cryptic for average users to grasp. Ubuntu ships with the interpreted and easy to learn Python language, along with full GUI programming modules(Gtk/Gnome or Qt for Kubuntu). Hidden away in Ubuntu's menu editor is an entry to run a Python shell interactively. To activate the entry, right-click the Applications menu and select "Edit Menus". In the "Menus:" section of the editor, go to Applications->Programming. You'll see two items show up in the "Items:" section. Check the box next to "Python (v2.5)", and close the menu editor. Now you will find the entry activated under Applications->Programming->Python, and an interactive Python terminal will pop up for you to learn and experiment.

Extending The File Manager
On Ubuntu, you can easily extend the functionality of the file manager, Nautilus, through executable scripts. They can be written in Python, Perl, and even bash. To use a Nautilus Script, place the script in the $HOME/.gnome2/nautilus-scripts directory, select any files/folders to be passed to the script, then right-click your selection and navigate to Scripts->YourScript. To get a good idea of what scripting Nautilus can do for you, I've created a collection of scripts used for programming, multimedia conversion, and even blogging(I'm using my "BlogShell.sh" script right now to make this entry). Kubuntu users have a similar feature called "service menus". You can find an excellent source of service menu scripts here.

Creating GUI dialogs on the command-line
Going hand-in-hand with file manager extensions are the tools zenity(for Gnome/XFCE) and kdialog(for KDE). These comman-line tools can create several GUI-based dialogs that are used within shell scripts. Ubuntu has excellent documentation for zenity, obtainable by clicking the "?" icon next to the main desktop menu and entering "zenity" in the search box. Kubuntu users need only enter "man:kdialog" within Konqueror.

]]>