Taken from the website:

The Play! framework makes it easier to build Web applications with Java. It’s a clean alternative to bloated Enterprise Java stacks.

First off, I have to say I am a fan of Rails for deploying web applications, and the Play! framework is just as easy. Once installed you can create a project

~$play new project

and then easily deploy (albeit boring and default) it:

~$play start project

No setup files and no need for Tomcat, simple and awesome. Of course, Rails developers won’t be too impressed, but it is a breathe of fresh air for those Java folks. As far as development goes, using the Play! framework is pretty straightforward. The project adheres to the MVC paradigm and forces you to as well. You place all of your Models in the app/models folder, all of your Controllers in the app/controllers folder and you place all of your Views (html files in this case) in the app/views folder. Keeping this setup and maintaining the MVC ideal gives you great power out of the box, and all without needing to program any glue to make these pieces work seamlessly together.

Of course there are other features that make the Play! framework appealing. For one, it does offer an “instant compile”, which really isn’t instant but allows you to view code changes as soon as your page is refreshed. Another feature is the increased support for debugging source code. Any compile errors will be displayed in your browser:

This is especially nice for those accustomed to JSP because your view will actually show you where the break occurs. This and other system messages are logged in the logs/ directory. Enticed yet? Along with all of this, the Play! framework has the ability to “eclipsify” your project so that it can be modified and tested using the Eclipse IDE. To do this you go to the parent directory of your project and simply run:

~$ play eclipsify project

Then you can import into Eclipse using the “Existing Project” import option. Netbeans is also supported with a similar one line command. With a fast deployment scheme, instant compiles, better debug feedback from JSP, and multiple IDE support the Play! framework truly makes it easier to build web applications with Java.

Check it out and let us know what you think!

Also keep an eye out for our upcoming guide to getting started with Play!

Virtualization has always held a special place in my toolset because it allows me to make modifications to my environment without the headache of potentially breaking something. So, any improvements on this front tend to grab my attention.

Recently, I came across AQEMU a GUI frontend to QEMU. For those of you who may not know, QEMU is an Open Source command line application that has support for CPU and System emulation. Now when it comes to virtualization I am a big fan of Virtualbox and VMplayer because of their straightforward GUIs and speed of setup. So, that being said, one of the things that has always turned me off from QEMU was the lack of a decent frontend. AQEMU has given me new hope, and with an interface similar to Virtualbox I find myself up and running AQEMU with very little headache.

Of course the greatest benefit of running QEMU is the fact that architectures other than x86 are slowly being added to the support list. In other words, you can emulate an old PowerPC or SPARC system on a more readily available x86 using QEMU. For those brave developers needing to develop cross architecture applications, this is just one more tool to make their lives easier. If you know all the dirt on what processor you need to run, AQEMU’s sleek interface allows you to setup that configuration quickly and easily.

Adding a new VM for the standard x86 System emulation is also easy:  click the Plus sign, give the VM a name, then specify your hard drive images in the HDD tab or cdrom iso in the CD/DVD/Floppy tab, and hit the play button.  To get up and running with AQEMU you will need to install QEMU and grab the AQEMU package from here. If you are running Ubuntu you can just grab the .deb package and then issue these commands in a terminal to install:

~$ sudo apt-get install qemu
~$ sudo dpkg -i aqemu-0.6.deb

When you first startup the application it will ask you to set up your configuration:

If you don’t need any special features, or if you just want to get running, click okay and the default settings will be applied. After that you should be good to go! Check it out and let us know what you think.

If you have ever needed to work with multiple version of a file, you’ve probably worked with diff. If you were ever wondering if there was a straightforward GUI compliment to diff, well, Meld might do the trick. At version 1.2.1 Meld offers many features like 3 way compare, directory compare, and a version control browser (subversion, cvs, bazaar-ng, Mercurial). It is a great utility for a developer doing source comparison. The program is written in python and offers a sleek gnome2 based interface that is quite intuitive. Meld offers an easy way to transition code from one version to another with a simple mouse click. This feature alone makes merging branches easy:

Did I also mention that files can be modified in place, and the file comparison will be updated dynamically?  Meld will greatly enhance your work efficiency and help eliminate typos while making branch maintenance a breeze. You can grab Meld here, but be sure you have the gnome2 libs, at least python 2.3, pygtk2 and gnome-python2 installed. If you are running Ubuntu, you can do all of that in one line:

~$ sudo apt-get install python-gnome2 libgnome2-0 python-gtk2 python

Next you can unzip the archive and run it. In the example below I actually installed Meld to my /usr/local/bin making it a one line executable from anywhere:

~$ tar -xvzf meld-1.2.1.tar.gz
meld-1.2.1/
meld-1.2.1/misc.py
...
meld-1.2.1/prefs.py
meld-1.2.1/MAINTAINERS
~$ cd meld-1.2.1/
~/meld-1.2.1$ sudo make prefix=/usr/local install
~/meld-1.2.1$ cd
~$ meld

You are now good to go. Check it out, and let us know what you think!

In this day and age, encryption has become the focus for securing sensitive data like bank account information, software licenses, or even social security numbers. If you have ever wanted to keep specific folders in your home directory encrypted in Linux there are a multitude of ways. Cryptkeeper and K-encfs come to mind. Both applications use Encfs to create and access encrypted folders. I have found Cryptkeeper to run well in KDE4, and since it is in Ubuntu’s Universal repository it was natural to quickly adopt. To install head on over to a terminal and (if you have the Universal repository in your repository list) enter the following:

~$ sudo apt-get install cryptkeeper

You should now be good to go, and find Cryptkeeper in your System applications folder. Now that it is installed, this might be a good application to add to your startup so you don’t have to do the pre-coffee click-all-fancy-app jig in the morning. To add to Cryptkeeper to your KDE startup create a link in your ~/.kde/Autostart folder. To do that we need to get to the Autostart folder.  Open up a terminal session and type in the following:

~$ dolphin ~/.kde/Autostart

Right click in the newly created Dolphin window and select Create New -> Link to Application and enter the following:

Now it should come up every time you log in. Go ahead and start it up now, and create a new folder by clicking on the Cryptkeeper tray and selecting “New Encrypted Folder.”  You should get a window like this:

Enter in the name of the folder you wish to create, click Forward, and then enter a password. You will now be able to mount or unmount this folder easily through the system tray.

After playing around with Cryptkeeper, you’ll find that the application itself is pretty simple, giving you the ability to create, import, mount or unmount an Encfs folders. For anybody looking to keep prying eyes out of personal files, Cryptkeeper does the trick.

Since Cryptkeeper does use Encfs under the covers it might be good to know a few disadvantages exist. First, lets start by saying remember your password, Encfs doesn’t have a multiple key system so if you lose your password an admin can’t help you out. Also file attributes remain viewable. I have created a folder called “secret” which can be found as .secret_enfs in my home folder. I’ve opened up my .secret_enfs folder and then used Cryptkeeper to mount this folder so you can see below:

Even though the attributes remain in place, filenames and contents are hidden. Lastly encryption is done in real time and very CPU costly so I wouldn’t suggest using it with large files. All that being said,  it is a quick and easy way to protect files in your home directory or on a pendrive.

Check it out and let us know what you think!

Being able to add some sort of client/server model to your programs is pretty essential these days, and Ruby does a fine job making your life easier.

For this article, I’ll show you a quick, down-and-dirty way of getting a very simple server up and running and a client that will say “Hello Server World” and disconnect. You will, of course, need Ruby installed, for Ubuntu users

sudo apt-get install ruby

and for Fedora users

sudo yum install ruby

Now, the first plan of action for a client/server assignment is to map out what exactly you want to occur. Setting those expectations in comments before you even think about code a good practice and will make your life a whole lot easier. That being said, let’s start with the server, by adding the following to a file we’ll name server.rb:

#establish server
#setup to listen and accept connections
#start new thread conversation
#reply with goodbye
#end loop

Now let’s do the same thing for the client script but name it client.rb

#establish connection
#send a quick message
#wait for messages from the server
#if one of the messages contains 'Goodbye' we'll disconnect
#end loop

Okay, now, lets get coding. There is only one requirement for writing these scripts, you will need to add:

require 'socket'

to the top of your script so that you have access to the TCPServer class. The TCPServer constructor needs at least port number, so I’ll set it up with port 2008. Also, we want to be able to have the server allow many clients to connect so we will need some sort of Thread structure built in to handle multiple requests. We will then accept any incoming TCP connections on port, 2008 say “Welcome” to the client, and wait for any response.” To keep this tutorial short, the server will be implemented in a forever loop that constantly listens for connections. Edit your server.rb file to follow what I’ve outlined above (I’ve used ## to denote comments further explaining what is going on) :

#!/usr/bin/ruby
require 'socket'

puts "Starting up server..."

# establish the server
## Server established to listen for connections on port 2008
server = TCPServer.new(2008)

# setup to listen and accept connections
while (session = server.accept)

 #start new thread conversation
 ## Here we will establish a new thread for a connection client
 Thread.start do

   ## I want to be sure to output something on the server side
   ## to show that there has been a connection
   puts "log: Connection from #{session.peeraddr[2]} at
          #{session.peeraddr[3]}"
   puts "log: got input from client"

   ## lets see what the client has to say by grabbing the input
   ## then display it. Please note that the session.gets will look
   ## for an end of line character "\n" before moving forward.
   input = session.gets
   puts input

   ## Lets respond with a nice warm welcome message
   session.puts "Server: Welcome #{session.peeraddr[2]}\n"

   # reply with goodbye
   ## now lets end the session since all we wanted to do is
   ## acknowledge the client
   puts "log: sending goodbye"
   session.puts "Server: Goodbye\n"

 end  #end thread conversation
end   #end loop

Cool, the server is written. If you run this script, it won’t look like much so lets just let it go for now. The client is pretty simple, we just want to say Hello, wait for any messages back from our super sophisticated server, and disconnect if the server says ‘Goodbye’.

Modify your client.rb file to look something like this:

#!/usr/bin/ruby
require 'socket'

# establish connection
## We need to tell the client where to connect
## Conveniently it is on localhost at port 2008!
clientSession = TCPSocket.new( "localhost", 2008 )

puts "log: starting connection"

#send a quick message
## Note that this has a carriage return. Remember our server
## uses the method gets() to get input back from the server.
puts "log: saying hello"
clientSession.puts "Client: Hello Server World!\n"

#wait for messages from the server
## You've sent your message, now we need to make sure
## the session isn't closed, spit out any messages the server
## has to say, and check to see if any of those messages
## contain 'Goodbye'. If they do we can close the connection
 while !(clientSession.closed?) &&
          (serverMessage = clientSession.gets)
  ## lets output our server messages
  puts serverMessage

  #if one of the messages contains 'Goodbye' we'll disconnect
  ## we disconnect by 'closing' the session.
  if serverMessage.include?("Goodbye")
   puts "log: closing connection"
   clientSession.close
  end
 end #end loop

Now open up two terminal sessions, and, from the directory you were editing your client and server scripts from, run them.

Localhost Terminal Session 1

~$ ruby server.rb
Starting up server...
log: Connection from localhost at ::1
log: got input from client
Client: Hello Server World!
log: sending goodbye

Localhost Terminal Session 2

~$ ruby client.rb
log: starting connection
log: saying hello
Server: Welcome localhost
Server: Goodbye
log: closing connection
~$

Of course the server running in terminal session 1 will continue running until you hit Control-C to stop it. If you have port 2008 open, you should now be able to run the client script from a remote computer if you change ‘localhost’ to the ipaddress of your server. My server resides at “192.168.0.127″ and my client resides at “192.168.0.141″. I modified the ‘clientSession” line to look like this:

clientSession = TCPSocket.new( "192.168.0.127", 2008 )

Then, I ran this across my small network and saw:

on Server Side terminal:

macbook:~ presenter$ ruby server.rb
Starting up server...
log: Connection from sparta at 192.168.0.141
log: got input from client
Client: Hello Server World!
log: sending goodbye

on Client side terminal:

codenomad@sparta:~$ ruby client.rb
log: starting connection
log: saying hello
Server: Welcome sparta
Server: Goodbye
log: closing connection
codenomad@sparta:~$

Now, if you really wanted to add some more features, try adding the ability to respond to messages sent by the client in the server script or try to raise or rescue exceptions when a connection is lost. You can see the types of exceptions that TCPServer raises here under either Unix-based Exceptions or Windows Exceptions. Good luck with creating your client/server app, and happy coding!

For those whose music is encoded in ogg or FLAC, well, Floola can also convert these formats so that they are playable on the iPod. You can even manage the notes on your iPod. The greatest part is that the software is cross platform and runs on Windows, Mac OS X, and Linux. If you are running Ubuntu you will need either libxine or gstreamer and libstdc++5 (for notifications you’ll need libnotify as well). These can all be installed pretty easy by running:

sudo apt-get install libstdc++5 libxine1 libnotify-bin

After that completes you can grab the Floola download here

You will then need to unzip the archive and copy to your /usr/bin. Assuming you downloaded it to the desktop you can issue these commands:

~/Desktop$ tar -xvzf Floola-linux.tar.gz
~/Desktop$ cd Floola-linux/
~/Desktop/Floola-linux$ sudo cp Floola /usr/bin/

Be sure your ipod is plugged in and now you can run it:

~$ Floola

The first time you run Floola you will need to go through a simple setup:

Select your iPod version:

And now you are good to go:

You like Floola? Let us know what you think!

AjaXplorer is quite a unique tool, and if you haven’t heard of it you might want to check out the latest 2.3.8 version. Essentially, AjaXplorer creates a web-based file manager using, you guessed it, Ajax. You can upload and view files, edit text files, create folders, and move or rename files and folders. Standard stuff maybe, but the beauty is that it can all be done from within your web browser at home, at work, or on the road. The setup is pretty easy, all you need is a working Apache server with PHP support. From Ubuntu you can enter:

~$ sudo apt-get install php5 apache2 libapache2-mod-php5

Then, go grab the latest version. Then you will need to unzip the contents of the file and put it into the Apache web folder.

~$ unzip ajaxplorer-core-2.3.8-dist.zip
~$ sudo mv AjaXplorer-2.3.8/ /var/www/explorer

We need to change some permissions on the files folder and on the server folder. These folders need to be writable, and we’ll restart apache to make sure everything is in place.

~$ sudo chmod -R 777 /var/www/explorer/files
~$ sudo chmod -R 777 /var/www/explorer/server
~$ sudo /etc/init.d/apache2 restart

Now you can check to make sure it is here by clicking http://localhost/explorer. As soon as the AjaXplorer loads you should be prompted to change your default admin password from ‘admin’. After doing that you can start to setup your repositories and users. Now this setup might be good enough for an internal trusted network, but I would recommend that anything done over the open web should be encrypted. Luckily AjaXplorer also kept this in mind and has a bit of documentation on how to set that up in section 8.7 of their F.A.Q. You will also need to be sure to restrict access to

/var/www/explorer/server/conf

and

/var/www/explorer/server/users

as soon as you have completed your configuration. According to the website, AjaXplorer uses .htaccess files to protect these directories. The interface is pretty easy to navigate, though there are still a few interface bugs.  You can see some screenshots below of my tests using Firefox 3, Camino 1.6.5, and Safari 3.2.

One of the coolest features is the ability to use a MySQL database as your ‘repository’.

If you are creative there are a lot of great things you can do with this, like manage a dynamic photo album’s pictures or even use the explorer as a type of collaboration tool. Check it out and let us know what you think!

ClamTk just released the latest version of their frontend to Clam AntiVirus which “brings back the Debian builds.”

If you’ve never heard of Clam AntiVirus (aka ClamAV) before it is an Open Source antivirus solution for Linux. Over the years ClamAV has gained much popularity, and has been used by many companies small and big alike to scan incoming email. With ClamTk you can harness this power on the desktop, and with the new 4.04 release you are only a dpk -i away from trying it out, sort of…

As the homepage states ClamTk 4.04 is the first 4.x release to have a Debian package. That being said the latest version hasn’t hit the repositories. If you are running Ubuntu or Debian you can still try out the latest version of ClamTk by grabbing a copy here.

Be sure to install gtk2-perl to satisfy dependencies by running

sudo apt-get install libgtk2-perl

Then you can install the .deb package by running

sudo dpkg -i clamtk_4.04-1_all.deb

Check it out, and let us know what you think!

So, after thousands of lines of code you’ve managed to build an awesome, feature rich program, and you are really to label it 1.0. You want to bring in more developers because it is doing so great… What do you do? Well, regardless of whether you have hit 1.0, version control is something that should be considered from a project’s inception. It will allow you to collaborate and share code with a team, or the world. That being said, how does one set up control versioning? Enter Subversion, this article will show you how-to setup a subversion server and Eclipse for sharing? Read on!

If you are running Ubuntu, the install is fast and easy.

codenomad@sparta:~$ sudo apt-get install subversion

If you are running Fedora, you have a simple one line command as well:

codenomad@sparta:~$ sudo yum install subversion

(Note: There is also a good graphical front-end to subversion for KDE called kdesvn that allows you to create and manage subversion repositories. For now, lets do this the command line way, it’s pretty easy.)

We are now ready to start. You must first create a repository to store all of your configuration files for subversion, and, of course, your code. I like keeping server information in my /var directory so lets create a subdirectory for subversion:

codenomad@sparta:~$ sudo mkdir -p /var/subversion/

Now lets add the repository (Note: Standard security practices should be considered here. I’m creating a directory that I can have access to without requiring admin privileges):

codenomad@sparta:~$ sudo chown codenomad subversion
codenomad@sparta:~$ chmod 755 subversion
codenomad@sparta:~$ svnadmin create /var/subversion/my_project

This should setup everything you need to get started. Go into the /var/subversion/my_project/conf folder and you should see some files:

codenomad@sparta:/var/subversion/my_project$ cd conf
codenomad@sparta:/var/subversion/my_project/conf$ ls
authz  passwd  svnserve.conf
codenomad@sparta:/var/subversion/my_project/conf$

You will need to modify the passwd and svnserve.conf file with the usernames and passwords of those who need to have access to the repository. First, lets modify the passwd file. Since the ‘#’ are comment lines, lets remove those and add a user name (I will use codenomad as my username and supersecret as my password) :

### This file is an example password file for svnserve.
### Its format is similar to that of svnserve.conf. As shown in the
### example below it contains one section labelled [users].
### The name and password for each user follow, one account per line.

[users]
# harry = harryssecret
# sally = sallyssecret

should now look something like this:

### This file is an example password file for svnserve.
### Its format is similar to that of svnserve.conf. As shown in the
### example below it contains one section labelled [users].
### The name and password for each user follow, one account per line.

[users]
codenomad = supersecret

Now we need to modify the svnserve.conf file. This file allows you to edit all the server specifics. For this situation we will need to give authorization to codenomad and tell subversion to look for the user information (the user password) in the passwd file. Looking at this file, you will note there is a [general] section. This is where you need to give authorization to your users.

My section looks like:

[general]
### These options control access to the repository for unauthenticated
### and authenticated users.  Valid values are "write", "read",
### and "none".  The sample settings below are the defaults.
codenomad = write
# anon-access = read
# auth-access = write

Just below the access section, uncomment this line:

password-db = passwd

NOTE: Be sure when you make these modifcations, there should be NO spaces at the beginning of the lines. In other words, the c in codenomad lines up with the very first space of the file. This will cause problems later on if you don’t take care

Now we can start the svn server in daemon mode giving it the root directory of our project:

 svnserve -d -r /var/subversion/my_project/

Everything is now setup from the subversion side!

Since I use Eclipse for a good majority of my work I’ll use this new repository to house “My_Project”. If you don’t already have the Subversive plugin installed in Eclipse, go to Help > Software Updates. Then from there, select the Available software tab, Click on Ganymede, and then expand Collaboration Tools. Select all the Subversive packages

Then, on the right, you’ll need to click “Add site” and enter the plugin connectors information from Polarion’s website:

http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site

This is needed to be able to connect to your subversion repository in Eclipse. Hit okay, then select all the packages in that list:

Next, hit install, accept the agreements, and then say okay to restart Eclipse. Eclipse should then be ready to go and will be able to share your files. Right click on your Project, select Team, and then select Share Project.

Give the repository information (for this case it will be localhost since I am developing on the same box I am serving from).

Enter your username and password that you stored in the passwd file in the next window. Then, to promote good practice, enter in a detailed message about the code you are about to commit.

If you tweak your router settings or your firewall, you should be able to give access to others outside of your network and not just on this box. For that you should open up or forward external 3690 to your box. When all is said and done, you should have your project stored in a repository available to share with others! Happy Coding!

While configuring a firewall is by far the best way to secure your system, there are times when you need a way to access a remote server that doesn’t compromise security.

A quick fix for boxes that need to be in the De Militarized Zone (DMZ) for a short period of time is to modify your hosts.deny and hosts.allow files, normally located in the /etc directory. Simply, and as you can probably gather from the filenames, the files will either deny or allow access to servers running on your box. The hosts.deny allows you to specify hostnames, IP addresses, or domains you wish to deny access and the hosts.allow will let you allow access.

For a quick, down and dirty configuration denying all access to your box make sure your /etc/hosts.deny has the following:

ALL: ALL

With this simple addition your /etc/hosts.deny should look similar to this:

# /etc/hosts.deny: list of hosts that are _not_ allowed to access the system.
#                  See the manual pages hosts_access(5) and hosts_options(5).
#
# Example:    ALL: some.host.name, .some.domain
#             ALL EXCEPT in.fingerd: other.host.name, .other.domain
#
# If you're going to protect the portmapper use the name "portmap" for the
# daemon name. Remember that you can only use the keyword "ALL" and IP
# addresses (NOT host or domain names) for the portmapper, as well as for
# rpc.mountd (the NFS mount daemon). See portmap(8) and rpc.mountd(8)
# for further information.
#
# The PARANOID wildcard matches any host whose name does not match its
# address.

# You may wish to enable this to ensure any programs that don't
# validate looked up hostnames still leave understandable logs. In past
# versions of Debian this has been the default.
# ALL: PARANOID
ALL:ALL

Note: Similar to shell scripts the “#” is a comment line.  Also be sure to add an extra blank line at the bottom of the file.

Moving on, the hosts.allow has a lot more power with the default configuration because it will override anything that is listed in the hosts.deny file. Please take care to note the previous statement because the more information you know about which networks or IP’s you want to have access to your box the better. For now, lets say I want to connect to my computer at home when I am at work.  Before we can start, you’ll have to make sure your home server is placed in the DMZ area of your network.  Most routers have this feature built in so please check your manual for the specifics.

Let’s get started. At work I have the IP address 65.0.12.4. Since I only need SSH access from this location I can add

SSHD : 65.0.12.4

Of course, I use my laptop at work and there are a pool of IP addresses that I can potentially get, in other words, I might not always get the same address ‘65.0.12.4′. So what can we do? Well, the hosts.allow file also gives you the ability to specify a complete domain. I can give access to systems at mycompany.com by adding the following:

SSHD : .mycompany.com

Lets modify the /etc/hosts.allow file. Yours should look similar to this:

# /etc/hosts.allow: list of hosts that are allowed to access the system.
#                   See the manual pages hosts_access(5) and hosts_options(5).
#
# Example:    ALL: LOCAL @some_netgroup
#             ALL: .foobar.edu EXCEPT terminalserver.foobar.edu
#
# If you're going to protect the portmapper use the name "portmap" for the
# daemon name. Remember that you can only use the keyword "ALL" and IP
# addresses (NOT host or domain names) for the portmapper, as well as for
# rpc.mountd (the NFS mount daemon). See portmap(8) and rpc.mountd(8)
# for further information.
#
SSHD : 65.0.12.4, .mycompany.com

Now I have access from any of the IP addresses that are from my company’s domain. This should give you the basic idea of how to restrict services on a remote server with these files. With a little more Google searching you should be able to find that you can restrict access to different types of servers as long as they are ‘wrapped’ by TCP. In other words, pretty much any service compiled with the libwrap.a library can be restricted using this method.

You can read more about the hosts.allow and hosts.deny by looking at their manpages by entering the following in a terminal:

~$ man hosts.allow

or

~$ man hosts.deny

Of course this is not meant as a full time solution, but it does offer a quick fix for boxes that are on the open net for a limited time. Try it out, and let us know how it goes!

If you have ever been involved in setting up a small to mid size network that requires full access to roadwarriors, the ability to detect intrusions, and the need for a firewall, then you will know that it is no easy task. The commercial cost of this alone is enough to consume your entire budget for the network, and quite possibly, eat into the budget you need to buy the computers to run on the network. Try asking for that from a startup that can barely afford the computers! Of course, there are many opensource solutions that can give you all of what you need for free, but with a one man IT shop expect many long nights and truck loads of hot pockets.

There is a quick and very cheap alternative: Untangle. Offering quite possibly the best free network solutions I have seen thus far, Untangle is the one stop shop for any networking requirement. From VPN to intrusion detection, Untangle offers the best of the open source community and rolls it up into a very nice package that is easy to manage. The interface is clean, and each open source offering is presented as a rack mount server.

Below you can see a wide variety of offerings (taken straight from their site) that are available for free, and some commercial offerings that help make the most of your Untangle server.

Don’t have a server to spare?  Not a problem, virtualization is the key.  Not only did the Untangle team spend countless hours creating such a seamless, feature rich product that encompasses some of the best of the open source world (and a few pay for goodies), they went the extra mile and wrote an amazing tutorial on how to get Untangle up and running in a virtual environment here.

Check it out, and let us know what you think!!

Dealing with exceptions is a big part of any object oriented programmer’s job. We need to be able to recover from things like connect failures or syntax errors, and do so gracefully. Thankfully, raising and “rescuing” exceptions in Ruby is a fairly easy task. Let’s start with a basic example. We all know that dividing by zero is a very bad thing, so lets tackle that scenario.

For fun let’s test this scenario out in irb. If you didn’t know already, irb is a ruby shell that allows you to execute ruby code on a line-per-line basis and is a great way of checking those one-liners. Lets fire it up and give you a very brief exposure to it.

Note: Ubuntu/Debian users, if you don’t have irb you can install it simply by running:

sudo apt-get install irb

On to the goods… Open up your favorite terminal session and type in the following into an irb session:

i=1
i/0

Your output should look like this:

codenomad@sparta:~$ irb
irb(main):001:0> i=1
=> 1
irb(main):002:0> i/0
ZeroDivisionError: divided by 0
  from (irb):2:in `/'
  from (irb):2

As you can see you can assign values to a variable, and perform a quick operation on it in irb. You can go ahead and quit irb by typing in “quit”, and we’ll start writing a script to catch this troublemaking scenario.

Handing exceptions in Ruby is referred to as “Rescuing”. In Ruby to rescue exceptions we need to surround our trouble code with a begin/end statement. Below you’ll find that I’ve surrounded our divide by zero scenario by this begin/end structure, and rescued the exception by putting a rescue clause right before the ‘end’. Add the following to a file called rescue.rb:

#!/usr/bin/ruby
begin
  i = 1
  i/0
  rescue ZeroDivisionError
    puts "you divided by zero putts"
end

Make the file executable and let’s run it:

~$ chmod +x rescue.rb
~$ ./rescue.rb
you divided by zero putts
~$

What if you just wanted to rescue any type of standard error? Well, lets modify our script again to rescue a file open error using StandardError:

#!/usr/bin/ruby
begin
  i = 1
  File.open("ABSsdt.xyz")
  i/0
  rescue ZeroDivisionError
    puts "you divided by zero putz"
  rescue StandardError
    puts "you had an error of some sort"
end

Run it, and you should get something like this:

~$ ./rescue.rb
you had an error of some sort

Be sure to check the Ruby documentation when writing your code, and you can see what exceptions can be through by different method calls. (ie look at the Array.fetch() method call. )

Now that you know how to rescue exceptions and where to look for the types of exceptions a method call can make, what about raising exceptions? Well, thats just as easy lets make a new script named raise.rb and add the following:

#!/usr/bin/ruby
begin
 if (File.exist? "file_1.rb")
  puts "file found"
 else
  raise "File not found"
 end
end

If you don’t have file_1.rb in your running directory, this code will raise an exception! It’s as easy as that! For a quick list of exceptions check out Zenspider’s QuickRef site. At this point you have a basic idea of how to handle exceptions, whether you raise them or rescue them, in Ruby. Get out there and get scripting, and be sure to let us know how it goes!

$ sudo apt-get install sun-java6-jdk

I really like to have full control over my development environments, so I’m not going to grab Tomcat using apt (besides, I said the latest version). Go ahead and grab a zipped copy of the core distribution from the Tomcat website. Now that you have the latest and greatest lets unzip the contents of your .zip into a /usr/local/tomcat folder.

~$ unzip apache-tomcat-6.0.18.zip
~$ sudo mv apache-tomcat-6.0.18 /usr/local/tomcat

Now, before we can start the Tomcat server, we’ll need to make some of the script files executable (note: if you downloaded the tar.gz archive instead, these scripts might already have the executable bit on. To avoid any potential snags, I’d issue these regardless of which compressed file you downloaded).

~$ cd /usr/local/tomcat/bin
~$ sudo chmod +x *.sh

Since I’d like to check out the neat framework demo ZK has, I need to be able to deploy their WAR in my webapps.  To make deploying point and click, I’ll be using the Tomcat Manager. If you want to use the Tomcat Manager you’ll need to modify the users and roles specified in the tomcat-users.xml file located in the /usr/local/tomcat/conf folder. Modify this xml file to have something similar to what is below.  Be sure to change username to something more creative and change the password (I don’t suggest using your real password considering this is a flat file). The file should contains something like this;

<tomcat-users>
  <role rolename="manager"/>
  <role rolename="tomcat"/>
  <role rolename="admin"/>
  <user username="codenomad" password="supersecret" roles="tomcat,admin,manager"/>
  <user username="admin" password="secret" roles="manager,admin"/>
</tomcat-users>

That should just about do it. Let’s start up the server by running:

~$ sudo /usr/local/tomcat/bin/startup.sh

You can test your install by clicking here. You should see something like this:

If you need to shutdown the server you can issue a similar command:

~$ sudo /usr/local/tomcat/bin/shutdown.sh

Now that we have Tomcat installed, lets check out that ZK demo I was talking about. First, you’ll need a couple things. You’ll need the ZK binary and the ZK demo. Download both of those here.

Unzip those files and copy the .jar’s over to your Tomcat library (this will allow you to include all of the greatness that is ZK in your future webapps).

~$ unzip zk-bin-prof-3.5.1.zip
~$ unzip zk-demo-3.5.1.zip
~$ cd zk-bin-prof-3.5.1/dist/lib
~$ sudo cp *.jar /usr/local/tomcat/lib/
~$ sudo cp ext/*.jar /usr/local/tomcat/lib
~$ sudo cp zkforge/*.jar /usr/local/tomcat/lib

Next, you’ll have to restart your Tomcat server:

~$ sudo /usr/local/tomcat/bin/shutdown.sh
~$ sudo /usr/local/tomcat/bin/startup.sh

Head back to the Tomcat page here, and click on the Tomcat Manager link in the top left. Enter in the username and password you modified in the XML file above, and scroll to the very bottom where it says “WAR file to deploy”. Click browse, and find the zkdemo.war file in the unzipped zk-demo-3.5.1 folder that was unzipped earlier.

Next, click on the Deploy button. You should see that the zkdemo is now in the Applications list, and if you click on the link that Tomcat provides you’ll get a welcome screen:

Thats it! You have a fully functional Tomcat Server, and you can start developing with the ZK platform! Check out ZK’s site for more development information. Good luck, and happy coding!

A savvy scripter could get similar features using these tools, but space for maintain backups can really become an issue. From my experience, there are 3 main gui driving projects out there: Timevault, Flyback, and Back-In-Time.

TimeVault, an integrated, and advanced backup utility that is currently in launchpad for Ubuntu, offers features comparable to Time Machine. It includes pop up notifications and a snapshot browser that allows you to filter search results.  On top of that you are even given a graphical representation of a file change at the very top of the snapshot browser.

For those wishing everything to be maintained by the Operating System, this seems like a pretty solid choice and doesn’t skimp on the details when needed.  It is probably the best bet when looking for a solution that is system integrated, and for those looking to come as close to Apple’s Time Machine as possible (minus the eyecandy).

Above you can see a screenshot of TimeVault’s snapshot browser, including the aforementioned representation of file changes.  The next couple of solutions feel a bit more hands on, that’s probably because they don’t have the tight system integration that TimeVault does.

Flyback and Back-In-Time are the two other frontends I spoke of.  Using rsync and cron to maintain backups, they both maintain pretty similar features.

Both applications have snapshot capabilities, and have the basic usermode backup where a filesystems/folder with write permission can be backed up and restored. Their main windows are pretty straight forward and give you the standard views of timestamped snapshots for a given folder structure.

Each application can schedule when a backup is to take place and when backups are deleted. Of course you don’t want all those /tmp files so each application gives you the ability to enter exclude parameters for backups.

It all comes down to preference, and with multiple products out we have the best thing possible: choice.

While TimeVault offers features comparable to Time Machine and system integration, Flyback and Back-In-Time might be easier to dive into for some homebrew modifications.  You can check out TimeVault here, Back-In-Time here, or Flyback here.

Over the past couple of weeks I’ve dabbled with the idea to add a webcam to my personal site that monitored a couple of pet furballs. The task was not too straight forward. I ran into many hiccups with alpha software and missing libraries. Most of the software related to setting up a webcam server was severely outdated, and hadn’t received an update in many months. I tried camE and webcam (the two most standard daemon webcam servers), but they required far more thought in the security realm than I would have liked to invest in the project.

Minutes from assuming all was lost, I ran into a nice little piece of software named Palantir (yes, after that crystal ball thing in Lord of the Rings). The program was built with performance in mind, and can handle a fair load with old hardware. Offering streaming pix, sound, and even the ability to control (assuming you have the hardware) the motion of a camera, my search was finally at an end.

Adding a stream to my website was as easy as embedding an image in my webserver index.html file, and starting up the Palantir server. All you need is the address of the box running the server, and modifying the following line (replacing the 192.168.0.20 ip with your server’s address):

<img border="1" src="http://192.168.0.20:3000/" alt="[Live stream]">

You instantly have a live feed that will stay alive for the default 120 seconds. The project also gives you the ability to use a stand alone client instead of a browser to stream your shots (choose from a native QT linux app, a Java app, or even a Windows app).

You can see a demo stream where the above snapshot was taken at the Palantir site here. Check it out, and let us know what you think!

polishlinux.org has put together a great sneak-peak at the current incarnation of what will become KDE 4.2 directly from the SVN repo.

Overall 4.2 is looking to be a natural evolution to 4.1, which was a surprising leap over 4.0 from a user’s perspective given how disappointingly 4.0 was received from the end-user community (4.0 laid all the technical groundwork for the infrastructure, but still had a lot of UI rough edges that were all ironed out in 4.1).

Dolphin has gotten some minor tweaks and enhancements to make it a better everyday file manager like GNOME has or Finder, leaving Konqueror to be the browser (or advanced file manager for folks that liked that more complex interface).

Improvements to Konqueror include back-ported SVG support from WebKit along with KJS (KDE JavaScript Engine) and KHTML (KDE HTML Rendering Engine) seeing improvements inline with the WebKit work as well to improve rendering speed.

Okular has replaced KPDF as the default viewer for PDF, CHM, DJVU and graphic files.

Improvements to the Plasma manager and it’s embeddable components, Plasmoids, has been done but there are still instabilities there. Kickoff4 can be integrated as a Plasmoid and has some additional searching enhancements (that are a little wonky right now).

The author, Piotr, recommends people wait for the 4.2.1 release of KDE if they are planning on switching. This author cannot help but appreciate the irony of that statement given he has read that, and adhered to it, since he first got into Linux almost 10 years ago… “XYZ is looking awesome, but wait for the patch release ABC…”

As far as I can tell, Linux has been almost great on the desktop for 10 years, but continues to loose the battle against Audio, Video and Gaming which keeps it out of the mainstream every single time.

I also fully expect 100 people to tell me why I’m wrong… I was one of you from 1998 until about 2005 when I finally realized that Linux would never really be dominant on the desktop because it cannot deliver what the majority of people want.

That’s not saying it doesn’t deliver a great experience to some people… those people will post here rabidl about why it’s superior, but it still cannot deliver the experience that most people want.

I’d suggest waiting for the patch release

We have two basic ways of installing the log4r library. We can either install directly by grabbing the source or we can install using ruby-gems.

To install using the source head on over to the Sourceforge download page.

Extract the .zip or .tar.gz, enter the directory, and issue the install command

~$unzip log4r-1.0.5.zip
~$ cd log4r-1.0.5/
~/log4r-1.0.5$ sudo ruby install.rb

To install using ruby-gems, first make sure you have gems installed:

~$ sudo apt-get install rubygems

Then install the library:

~$ sudo gem install Log4jr

This should get you everything you need to get started. Now, lets look at the previously written
script:

#!/usr/bin/ruby
require 'time'

puts "starting fibonacci"

def fib(num)
 if(num < 2)
   return 1
 else
   return fib(num-1) + fib(num-2)
 end
end

if ARGV[0] != nil
 if (ARGV[0].to_i >= 35)
  puts "This might take a bit...."
 end
 start = Time.now
 puts fib(ARGV[0].to_i)
 stop = Time.now - start
 puts "Finding the fib of #{ARGV[0]} took:"
 puts stop
 puts "seconds"
end

We will need to add:

require 'log4r'
include Log4r

to the top to get access to the Log4r library.

Then we will need to create a logger. We’ll do this by adding another method to setup the global
logger. You can do this by adding:

def setupLogger()
  # create a logger
  @logger = Logger.new 'logger'
  @logger.outputters = Outputter.stdout
  @logger.debug "Logger is now setup"
end

{smartads}

to just before the fib() method call in your script.

Normally, I would set this up in an initialize method (for those unfamiliar with Ruby, this is like a
constructor method), but we’ll keep this simple for later examples.

I’m also going to replace all of the standard out (ie “puts”) messages, and
replace them to be logged with the DEBUG logger. Replace all ‘puts’ messages with “@logger.debug”.

For instance:

puts "Finding the fib of #{ARGV[0]} took: #{stop} seconds"

should now look like this:

@logger.debug "Finding the fib of #{ARGV[0]} took: #{stop} seconds"

Of course, we still want feedback from our program so let’s change the logger to output directly
to the console. You can actually see that this is already being done with this line:

  @logger.outputters = Outputter.stdout

After all of your edits, your script should now look like this:

#!/usr/bin/ruby
require 'time'
require 'log4r'
include Log4r

def setupLogger()
  # create a logger
  @logger = Logger.new 'logger'
  @logger.outputters = Outputter.stdout
  @logger.debug "Logger is now setup"
end

def fib(num)
 if(num < 2)
   return num
 else
   return fib(num-1) + fib(num-2)
 end
end

#start of main script
@logger.debug "starting fibonacci"

if ARGV[0] != nil
 if (ARGV[0].to_i >= 35)
  @logger.debug "This might take a bit...."
 end
 setupLogger()
 start = Time.now
 @logger.debug fib(ARGV[0].to_i)
 stop = Time.now - start
 @logger.debug "Finding the fib of #{ARGV[0]} took: "
 @logger.debug "#{stop}"
 @logger.debug "seconds"
end

If you try and run your script at this point you’ll notice an “undefined method `info’ for nil:NilClass (NoMethodError)” error. This is because you haven’t setup the logger before you started debugging. Lets move this log line to after the setupLogger() method call:

...
#start of main script

if ARGV[0] != nil
 if (ARGV[0].to_i >= 35)
  @logger.debug "This might take a bit...."
 end
 setupLogger()
 @logger.debug "starting fibonacci"
 start = Time.now
 @logger.debug fib(ARGV[0].to_i)
 stop = Time.now - start
 @logger.debug "Finding the fib of #{ARGV[0]} took: "
 @logger.debug "#{stop}"
 @logger.debug "seconds"
end

If you run your script now, it should work. Here is output from my run:

~$ ruby fib-log.rb 10
DEBUG logger: Logger is now setup
DEBUG logger: starting fibonacci
DEBUG logger: Fixnum: 55
DEBUG logger: Finding the fib of 10 took:
DEBUG logger: 0.000828
DEBUG logger: seconds

As you can see, adding a logger to your existing script is very easy, and you can get even more
fancy with the types of logs you wish to create. Since there are multiple
levels of logging (DEBUG< INFO < WARN < ERROR < FATAL), you can customize which level’s you use by changing the second qualifier (ie. @logger.debug could become @logger.info). Lets do that for
a couple of lines.

Change

@logger.debug "Logger is now setup"

to

@logger.info "Logger is now setup"

and change

@logger.debug "starting fibonacci"

to

@logger.info "starting fibonacci"

Your final script should look like this:

#!/usr/bin/ruby
require 'time'
require 'log4r'
include Log4r

def setupLogger()
  # create a logger named 'mylog' that logs to stdout
  @logger = Logger.new 'logger'
  @logger.outputters = Outputter.stdout
 @logger.info "Logger is now setup"
end

def fib(num)
 if(num < 2)
   return num
 else
   return fib(num-1) + fib(num-2)
 end
end

#start of main script

if ARGV[0] != nil
 if (ARGV[0].to_i >= 35)
  @logger.debug "This might take a bit...."
 end
 setupLogger()
 @logger.info "starting fibonacci"
 start = Time.now
 @logger.debug fib(ARGV[0].to_i)
 stop = Time.now - start
 @logger.debug "Finding the fib of #{ARGV[0]} took: "
 @logger.debug "#{stop}"
 @logger.debug "seconds"
end

Now let’s run the final script. You should have received output like this:

~$ ruby fib-log.rb 10
 INFO logger: Logger is now setup
 INFO logger: starting fibonacci
DEBUG logger: Fixnum: 55
DEBUG logger: Finding the fib of 10 took:
DEBUG logger: 0.000823
DEBUG logger: seconds

If you are looking for a quick way to add log messages to your ruby scripts, log4r might be a
very quick and easy to implement solution for you. Offering features comparable to Apache
Foundation’s log4j, you will find quite it quite capable of handing any of your current project’s
logging needs. Check it out, and let us know what you think.

If you are running Ubuntu the install is pretty trivial:

$ sudo apt-get install mono-2.0-devel mono-gmcs

Now we are ready to start.

Java developers will find that C# feels like a very familiar language.  Being a Java coder there were some nuances that caught me off guard while writing my first basic programs.  For instance, a basic “Hello World!” example can be written in a variety of ways.

For now, we’ll stick to the absolute basics which is conveniently the closest to Java. Add the following code to a file called hello.cs:

public class HelloWorld {
  public static void Main(){
    System.Console.WriteLine("Hello World!");
  }
}

Then, compile the example using gmcs:

$ gmcs hello.cs

You will see that the compiler created a hello.exe file which can be run using the Mono runtime.

$ mono hello.exe
Hello World!
$

One of the nuances I was talking about earlier was in reference to namespaces.  If you are familiar with C++, you will find that namespaces in C# function similarly. If, however, a bulk of your education was invested in Java, such as mine, you might be a little confused at first. Let me assuage any of those fears by stating that namespaces help more with code organization than anything else.  Let us rewrite the “Hello World!” example one more time using a namespace.

Add the following code to a file called hellonamespace.cs:

using System;

public class HelloWorld {
  public static void Main(){
    //Notice how the following line
    //is different from the first example
    Console.WriteLine("Hello World!");
  }
}

Now compile and run it….

$ gmcs hellonamespace.cs
$ mono hellonamespace.exe
Hello Namespace...errr World!

{smartads}

To explain a bit, the second hello world example used the System namespace. By using this namespace we were able to call WriteLine from the Console class without needing to fully qualify the class (ie. System.Console.Writeline). Imagine, for a moment, that a namespace is like a tool shed where multiple tools are housed.  If you exist in the tool shed you have the ability to use a hammer object or a saw object that also exist in the same shed.  That being said, multiple tool sheds can exist and some  may even have similar objects like a hammer or a saw.

If you are a Java programmer you might be thinking that package names are the equivalent.  You would be correct, but C# does not require class files to be stored in certain locations like Java convention does.  This is a great way to organize and allow for more flexiblility in a single file.

This is just a quick tutorial, however, and there are some more neat tricks that can be done with namespaces like namespace aliasing, external aliasing, and using the global:: operator which you can read more about here.

Let’s continue on.  Since I like the golden ratio, and because I think it makes pretty pictures,
lets go ahead and implement a Fibonacci example using C#.

Start by adding the following to a fib.cs file:

//Namespace
using System;

public class Fib {
  public static void Main(){
    Fib fibGenerator = new Fib();
    //Notice the subtle difference in outputting
    //variables.  This is similar to C/C++
    Console.WriteLine("The fib number of {0} is {1}",
                      10, fibGenerator.grabFib(10));
  }
  //Constructor Class
  public Fib(){}

  //Fibonacci Computer
  public int grabFib(int num){
    if(num < 2)
      return num;
    else
      return grabFib(num-1)+grabFib(num-2);
  }
}

Now compile and run it….

$ gmcs fib.cs
$ mono fib.exe
The fib number of 10 is 55
$

You should note that writing to the console was a little different here.  I was able to specify multiple variables in the Console.WriteLine call by using the “{0}” and “{1}” notation and placing the variables at the end respectively.  This borrows a bit from the earlier C languages, and is a nice way to keep console messages clean.

As you can see, if you want to learn C# and you have a Java background you will be able to pick the syntax up very quickly.  If you have had any object oriented experience it will definitely help in understanding basic C# conventions. The only way to find out is to dive in.  Give it a shot, and let us know what you think.

Well, Mono is an Open Source, ECMA compliant answer to Microsoft’s .NET set of tools.  Mono has been famed for it’s C# compiler and Common Language Runtime and has .NET compatible toolset that runs on a wide variety of *nix platforms including Linux, Mac OS X, Solaris, BSD, and yes, of course, Windows.

The Mono project was started by Miguel De Icaza of Ximian fame back in 2001. It made great progress on a seemingly impossible task with only a handful developers.  It was also well received in the OSS community and received corporate backing when the founding company, Ximian, was purchased by Novell in 2003.

With this release, Mono brings a whole slew of new features (straight from the website) including Compatibility with Microsoft’s:

• ADO.NET 2.0 API
• ASP.NET 2.0 API
• Windows.Forms 2.0 API
• System.XML 2.0
• System.Core
• System.Xml.Linq
• System.Drawing 2.0 API

Along with Microsoft API compatibility, the Mono project has also managed to expand its own APIs to include (again straight from the site):

• Gtk# 2.12 support
• Mono.Cecil
• Mono.Cairo
• Mono SQLite support
• Mono.Posix

{smartads}

The new release also features a Visual Basic 8 compiler and C# 3.0 compiler implementation fully supporting LINQ (A project started by Microsoft to create a set of extensions for the .NET framework which help simplify querying, selecting, and filtering all kinds of data sources ranging from arrays to XML files).

This release should be great news for those either needing to port .NET applications to other platforms or with projects requiring platform independence. Just in case you didn’t know how big this project has become you can check out the huge list of applications already using the Mono runtime here.

If you are a Windows developer that has an existing .NET 2.0 application in the field or are a *nix developer looking for cross platform tools consider using Mono.  After all, using Mono to develop your applications can only help increase your existing user base.   For more information check out the release notes here.

Like all internet enthusiasts, I was ecstatic to see Google release a new browser. Unfortunately, like all *nix enthusiasts, my heart dropped at the sight of “Google Chrome (BETA) for Windows” and no sign of a corresponding Linux or Mac version. Fortunately, the good guys over at Codeweavers released a version of Chromium (the codebase for which Chrome was built on top of) for both Linux and Mac. Being the curious little bugger that I am, I decided to give it a go on an old Pentium 4 Ubuntu desktop and my Core 2 Duo Macbook. Granted, my Linux desktop is a little old, but I figured it would be a good candidate for noticing speed improvements.

Since this test was for kicks, I only ran the SunSpider JavaScript benchmarks to get a simple idea of performance. JavaScript, as we now know, was one of the huge performance areas Google tried to tackle with their new process model. The SunSpider benchmark just happened to be a nice test to expose performance benefits (just like it did with SquirrelFish). Here is how Chromium panned out…

Part 1: Linux Results

On the Linux front, I was using a 1.8 Ghz Pentium 4 with 768MB RAM running KDE under Ubuntu 8.04. In the nature of simplicity, Codeweavers offers up a .deb package so the install was a simple one line dpkg command. To be more complete I wanted a comparison between a couple of browsers, so on Ubuntu I picked Opera and Firefox to compare against. I then ran the SunSpider benchmarks with Opera 9.52, Firefox 3.0.1, and CrossOver Chromium v. 0.9. The test was run in each browser one at a time and with no other applications running.

Initially, I thought Chromium felt pretty zippy on the Ubuntu box, and the benchmarks proved it. It was the solid winner in all categories with a speed 3.66 times faster than Opera and 2.08 times faster than Firefox. Each category total was recorded and those values are graphed below (shorter bars are better):

The aforementioned speedup came from the total time benchmark tallies of 9590.4 ms for CrossOver Chromium, 35103.2 ms for Opera, and 19975 ms for Firefox. There was no doubt that CrossOver Chromium was the clear winner here. For the visually oriented the total runtimes can be seen below:

Part 2: Mac Results

{smartads}

The Mac test machine packs a bit more of a punch with a 2.0 Ghz Core 2 Duo processor and 2 gigs of RAM running Leopard (10.5.5).

For the installation Codeweavers offers a standard .dmg file that mounts as a disk image. To install you are left to drag and drop Chromium onto the provided Applications alias.

Once all the applications were installed and up to date, I started the benchmark the same as with Ubuntu: one application at a time with nothing else running.

Below is a screenshot of Opera, Safari, and CrossOver Chromium with their respective results.

Once the tests had finished on Safari version 3.1.2 (build 5525.20.1), Opera version 9.52 (build 4916), and CrossOver Chromium v. 0.9 I compiled the results. Similar to the Ubuntu run, CrossOver Chromium for Mac performed very well breezing past Opera and Safari in all of the tests. Here are the individual results for Leopard (shorter bars are better):

The total benchmark tallies for the Mac run were 1592.6 ms for CrossOver Chromium, 6923.4 ms for Opera, and 3934.8 ms for Safari. For this run Chromium turns out to be 4.34 times faster than Opera for Mac and 2.47 times faster than Safari. Of course, Chromium was unquestionably the winner. Again, for a visual taste of the test:

Even though the Chrome Beta was intended for a Windows-based audience, Codeweavers managed to put out a nice appetizer for those lacking (by chance or choice) a Windows installation. This test’s purpose was just to see the performance of CrossOver Chromium compared to existing browsers of the same platform.

Please keep in mind that the software is still Beta, and no native version has been announced for Linux or Mac. That being said, CrossOver Chromium seems to be the sure winner on both test boxes with doubling and even quadrupling the speed of javascript execution comparatively. For Linux and Mac users, this should be a pretty good indication that a speedy new contender in the browser arena will be with us shortly.

Check it out here, and let us know what you think!

Since the dawn of the IT department there has always been 1 disk to rule them all.  A single rescue disk to save ailed hard drives, or, if all else fails, grab the last remnants of your frantic employee’s 400 page handbook on cold fusion.

Of course the reign began with bootable floppies, then bootable CD-ROMs, and now the ever-so-versatile bootable USB drive. Since the media technology has become more advanced so have the distributions. While you can install Linux on portable USB drives, I still prefer a good, old-fashioned, unborkable CD-ROM based rescue distribution. Enter SystemRescueCd, a simple, yet full-featured bootable CD-ROM that offers up the latest and greatest in workstation repair tools (taken straight from the website):

• GNU Parted
• GParted
• Partimage
• File systems tools
• NTFS-3G
• sfdisk
• Test-disk
• Network tools

For a long time I’ve felt that Linux-based rescue CDs were great for Linux workstations, and they even worked great if you needed to repair a FAT32 partition or mount NTFS as read-only (because read/write support was still experimental).

{smartads}

Since the completion of NTFS-3G, however, there is nothing to keep a Windows administrator tied down to commercial software.

This particular distribution does a great job reminding me of that. Using Partimage I was able to backup a partition to another hard drive. With Test-disk I was able to undelete FAT32 partitions I mistakenly borked, and I was able to resize my NTFS partition with GParted without the disclaimer stating that my drive could become unusable.

Accompanying all that is the ability to use SystemRescueCd remotely with the built-in VNC Server, backstore to keep your changes when you reboot the SystemRescueCd, and rsync for backing up laptop post-trauma data.