Over the last few weeks you might have seen a warning window like the one above (or similar to it) when visiting the site. Unfortunately it looks like some WordPress plugin-tinkering that I did right before going on vacation introduced an obnoxious malware hook into the site (don’t worry, it’s nothing epicly horrible).

I just finished manually cleaning it out using talgalili’s tip here. The infection was an invisible iframe-hack injecting a reference to the m-analytics.net site in every single .php or .html file hosted on the site — really obnoxious but easy enough to clear out and tighten up everything in the process.

Sorry you guys had to deal with that while I was gone, we should be good now.

Here’s the enum I had defined in one of my classes:

public static enum EventType {
    COMPONENT_ADDED,
    COMPONENT_REMOVED
}

It’s fairly straight forward what I was using it for — every time I fired an event of a certain type, I always make sure to set the type on the event, so the receiver knows what to do with it.

The situation I found myself in, is similar to MouseEvent’s use of the BUTTON constants in that when a new event of the specific type is created, the only valid eventType arguments allowed should be of ones defined in the enum itself.

NOTE: As I write this, it just dawned on me that this specific example is an invalid use-case, but I’m still going to finish the example because it’s really cool that you can define methods inside of enums. For those that haven’t caught my mistake yet, I’ll explain why this example is invalid at the end of the article.

In order to guarantee that the provided eventType is part of the defined enum, I sat down and started to write a simple boolean contains(EventType eventType) method in the parent event class… it was then that I realized “this feels wrong, this method that checks contains state should be defined in the enum itself — it’s the logical place one would look for such a thing”

After some digging online, it turns out defining methods inside enums is completely valid, becuase they are essentially classes. What I ended up with is the following:

public static enum EventType {
    COMPONENT_ADDED,
    COMPONENT_REMOVED;

    public static boolean contains(EventType eventType) {
        boolean contains = false;
        EventType[] values = EventType.values();

        for (int i = 0; i < values.length && !contains; i++) {
            contains = (COMPONENT_ADDED.equals(values[i]) || COMPONENT_REMOVED
                    .equals(values[i]));
        }

        return contains;
    }
}

So now when I receive an eventType in the constructor of the parent event, I can check it with a simple:

if(!EventType.contains(eventType))
    throw new IllegalArgumentException();

Very cool stuff.

CLARIFICATION: For those that didn’t catch my mistake with this example, you’ll notice the entire purpose for writing the contains(EventType eventType) method in the EventType enum is to verify that a given instance of EventType was defined in the enum — the answer is “of course it has been” — the only value I have to check for is null, if the value of the eventType argument is not null, it’s already guaranteed that it is a valid value from the enum, because it is an instance of the enum — so there is no need to check.

Even though I mad that glaring mistake with this example, I don’t want to think of another example on the fly that is more applicable, or dumb this one down to something really generic like the classic fruit-type example — instead the information provided should still be helpful if you are curious about learning about enums in Java 5 or later in more detail.

ADDITIONAL NOTE: I’m always surprised at the number of people that don’t know about using multiple-conditions in the standard for-loop above. It’s an awesome way to short-circuit an itteration when you find what you want.

At the end of January I ordered a nice shiny Lenovo Ideapad S10e from Buy.com. I managed to get a decent price that didn’t hurt the pocketbook, and it was a new toy that I could endlessly experiment with. I started to install a wide variety of operating systems to check for support and to put it through the paces.

Now, if you’re like me, you have a profound dislike for Windows Vista (especially on laptops). Of all the operating systems I’ve chosen to install on the 10e I decided to skip Vista because it takes forever to boot and nags you like a four year old for doing just about anything.

My interested was piqued when the beta for Windows 7 was released. During the time period that I was deciding to purchase the Ideapad, I managed to sign up for the Windows 7 test and downloaded the iso. I basically just had it lying around until my S10e arrived. What better a machine to install a brand new Windows operating system on than a shiny new netbook. I plunged…

Before this was possible, I had to get an external cdrom drive. I located a combo on NewEgg that included a 2GB stick of Kingston RAM and a highly portable, power adapter-less Samsung SE-S084 DVD Burner.

With that, the new specs are as follows:

10.1″ Screen (1024×576 remember this is the ‘e’ model)
1.6Ghz Atom
2 GB Ram (2 gigs is the max the atom can see)
80GB Hard Drive
802.11g
10/100BaseT
ExpressCard Slot

I went ahead, booted up with the Windows 7 install disk, and walked the paces.  My first impressions were good since the install took about 30 minutes (enough time to make a cup of coffee and read the latest Slashdot). Boot up speed was okay, I eyeballed  a little over a minute with my wrist watch, including the time it took to enter my password and log on.

Now, if you haven’t used Vista before, Windows 7 will look pretty different, and it will most definitely feel like the red headed, alien step child compared to Win2k or XP. Here is a little proof that it did actually install:

You might notice that the RAM registers at 2.5 GB. You might also notice that I said my machines specs are 2GB. I wasn’t lying. Unfortunately for me, the Atom chipset can only recognize and use 2GB of memory. That means that the standard (and soldered-on) 512MB is nothing more than a space hog internally disabled.

Gripes about the chipset aside,  I really wanted to see how this little Ideapad would stack up so I started the benchmark tools that Windows 7 came with to see how it ranked. After a couple of minutes, the score came to 2.2, the lowest score achieved among all the tests. A screenshot can be seen below.

Not too surprised by the score (it IS a netbook), I decided to check Windows Update to make sure there weren’t any outstanding video, sound, or otherwise performance enhancing updates. Naturally, there were three. I went ahead and updated, rebooted, and started the test over. Nothing changed, I still managed a 2.2. Oh well.

The next  big thing I wanted to test was Power Mangement, and I have to say I was pretty impressed with the sleep/wake function (key for being able to be constantly on the run). Know that I am a Mac user half of the time (the other half an Ubuntu user), and know that Apple has spoiled me pretty bad as far as the Sleep/Wake capabilities of a laptop. Fanboy silenced, I’m impressed. The Lenovo takes a little bit longer than my Macbook to wake from sleep, but is usable in well under two seconds. The stock XP install took closer to 10 seconds to wake and ‘do it’s thing’.

Unfortunately, I did notice something a little odd after putting the Ideapad to sleep and then waking it. There seemed to be a high pitch sound that randomly starts within a couple seconds of waking up. I’ve whittled this down to a driver issue since the high pitch sound goes away when I increase or decrease the volume. I went straight to the RealTek site, grabbed the latest drivers for the sound card  (2-24-09) and installed them. This seemed to do the trick.

Next up was battery life. I know the true purpose for these little machines isn’t to watch a DVD, but it is is something I’ll at least want to be doing at every now and again. I wasn’t going to be using wireless during this time, so I turned it off as well as decreased the screen brightness to half of its normal output. Next, I popped in a 16:9 DVD, and here is what I saw:

Using Windows Media Player, the DVD opened up in perfect widescreen mode with no black borders. This is thanks to the native 1024×576 resolution on the 10e (remember the .1″ difference in screen size compared to the S10). Normally, I wouldn’t have accepted the loss in prime 24 pixel real estate, but so far I haven’t found it a problem. In this case, it actually makes it the perfect screen for viewing widescreen dvds.

Sadly my viewing pleasure came to an end about 10 minutes too early. The battery power had been depleted and Windows started to hibernate the netbook at 6% battery life. I’m sure there was some sort of modification I could have made to prevent it, but in all honesty 6% wouldn’t have given me much to work with anyways. I was going for minimal tweaks so beyond changing the the screen brightness and the power saving setting I don’t think a normal user would think of anything else.  In the end, the 1 hour 51 minute runtime is still a little unimpressive for the machine but it is okay. I have to give some credit to the S10e since the Samsung external DVD drive is completely USB powered.

That being said, I didn’t want to leave the experience with a crutch so I decided to help balance it out by rerunning the battery test with another movie imported to h.264 and on an SD card. This is the more ideal situation for me, since I will mostly be watching movies mostly from SD cards instead of a cumbersome external DVD setup.

Under an hour and a half into the movie I checked to see the time left on the battery. To my dismay, 26 minutes were left. Looks like the external DVD drive didn’t consume that much power after all. Again, Windows decided to hibernate at 6% and I was still missing about 5 minutes of the movie. As far as Windows 7 is concerned, battery life conservation when watching DVD or DVD quality movies is poor despite enabling ‘Power Saving’ and disabling wireless.

After the movie test I decided to ease up a bit and retest the ‘Power Saving’ setting in Windows 7. I managed to get about 2.5 hours of ‘normal use’ out of the netbook when web surfing, and writing emails. Nothing too spectacular, but on par with other netbooks running XP.

Since I did have the DVD Burner, I wanted to test out Windows 7’s support for burners. I downloaded the latest MythBuntu ISO, right clicked, and I had an option to burn the ISO. Very nice. I was able to burn the ISO without needing any extra software. I did run into a little problem though. Before I burned the ISO I selected the option to verify the disk when it completes. The verification pop up never completed, and left me with this on screen:

The disk did, however, burn successfully. Next, I installed Safari to test drive the massive Javascript improvement Apple has been touting. The install went clean, and I was presented with a fairly nice interface on the little netbook screen.

I almost preferred this to Firefox since the address bar didn’t take up as much screen real estate. It ran pretty nice making Gmail quite a bit zippier. I also ran some Sunspider benchmarks comparing IE and Safari and there wasn’t really much of a competition.  Safari won hands down with final tests running 5x faster than IE. That just solidified my stance that my prefererence is not for IE and I don’t think Windows 7 will change it.

After spending a couple days with Windows 7 on the S10e, I feel that it was at least on par with the performance of Windows XP, and much better than the initial Vista release I had experienced on other, more powerful laptops. I was happy with the built in features: a new and clean interface, ability to burn ISOs without extra software, complete hardware support for the netbook, and okay power savings. As it has more time to mature, I’m sure Windows 7 might be a viable contender on these new Atom-based machines.

Windows 7 Screenshot Gallery

For a quick reference, here’s the breakdown of just the java.lang Exceptions:

Caught the introduction of this story over on OS News — apparently folks have been voting on the addition of a global, application-context sensitive menubar in Gnome for a while. The design of the bar is very similar to the way the global bar in Mac works. For those that don’t know, there is a universal menubar across the top of any Mac OS X desktop:

the contents of the menubar changes depending on the application that is currently focused. This is different (and sometimes strange) for Windows users that expect to see the application’s menubar inside the application itself (File, Edit, View, etc. menus).

The Linux/Unix desktop environment, GNOME, has always behaved similarly to a Windows desktop, with the applications managing their own menubars. However, given GNOME’s drive to be a simple/intuitive desktop (and the default for the popular Ubuntu Linux distribution), there has always been a very Mac-esque feel to the advancements that GNOME has taken with UI development… almost a hybrid between what Windows would do and what Mac would do. Because of this line that GNOME tended to walk, the desire to have a Mac-esque universal menubar isn’t too far of a stretch for the imagination.

Having this battle fought back in 2006 on Bugzilla resulting in some buggy and initial attempts at a global menubar, the effort never really got the steam it needed to be a viable solution for folks (or make it into GNOME proper). Fast-forward to today, and enter the very intuitive and flexible solution: gnome2-globalmenu project

As you can see from the screenshot above, globalmenu is a GNOME applet, requiring no hacked GTK builds or special GNOME builds — simply follow the dead-easy Ubuntu install instructions (or generic install instructions). For the Ubuntu folks, you’ll want to register the following repository depending on the Ubuntu version you are on:

• Ubuntu 9.04 – Jaunty Jackalope:
  • deb http://ppa.launchpad.net/globalmenu-team/ppa/ubuntu jaunty main
  • deb-src http://ppa.launchpad.net/globalmenu-team/ppa/ubuntu jaunty main
• Ubuntu 8.10 – Intrepid Ibex:
  • deb http://ppa.launchpad.net/globalmenu-team/ppa/ubuntu intrepid main
  • deb-src http://ppa.launchpad.net/globalmenu-team/ppa/ubuntu intrepid main
• Ubuntu 8.04 – Hardy Heron (LTS):
  • deb http://ppa.launchpad.net/globalmenu-team/ppa/ubuntu hardy main
  • deb-src http://ppa.launchpad.net/globalmenu-team/ppa/ubuntu hardy main

NOTE: When registering the repository, be sure to check the Add Source box as well, that will automatically add the deb-src entries above to your sources list.

Next, on the Authentication Tab, you can import the gnome2-globalmenu GPG repository key to authenticate the software against, and then hit Reload and you are all set. When you are done the applet installed and listed in the GNOME Add to Panel dialog:

and away you go!

Configuring globalmenu is straight forward, with some basic preferences you can choose:

and usage is automatic… when you fire up an application, it’s menu-bar does not exist in the application’s window, but is instead promoted to the top of the screen to the global menubar:

Right now only GTK-based applications are supported, so for applications like Firefox and OpenOffice, the menubars will still exist inside the application’s main menu, but this is an excellent start to the work.

Let’s hope this rolled into a future GNOME release and built on!

Lets face it, some sectors just can’t move to Linux due to legacy application support, lack of personnel support, employee training, and especially due to the jump in vastly different user interfaces. Each company has their own incredibly (insert sarcasm) unique reason for holding back. So, what is left for the network admins to do other than to support the Windows base? What if there were more than 10, 50, or even 100 computer involved and your admin staff is less than 5?

As some of you might know, I use to manage a network of computers for a small office supply way back in the day. The one thing that I wanted most was to have a standard image to distribute to all the machines at any given time. Being the sole administrator working part time, remotely, and basically with no budget my options were severely limited. I longed for a solution that gave me the power to use 1 machine to create a custom image that could easily distribute security updates, software configurations, printer setups, and network shares. Those days are long gone, but a solution to this common problem has cropped up. Enter FOG, “a free computer cloning solution.”

FOG was created as a solution to a non web-based, expensive re-imaging product that often required the use of driver disks. FOG incorporates the use of TFTP and PXE to do its remote imaging, and a webserver to do the administration.

The install is pretty easy, and the wiki has step-by-step instructions for Ubuntu and for Fedora. Since the wiki has some great information on setting up FOG, I’ll refrain from duplicating documentation. Check out the User Guide wiki here.

Once you startup the install script you’ll be prompted for a Server type, your server address, your DHCP router address, and if you want to use your server install as a DHCP server. I went with the defaults giving the ip address of my server, using my router as the dhcp server, and not enabling FOG as the default DHCP server. Once the install gets going you should see a similar window:

After that is done, you’ll be able to login to your freshly installed imaging server. There are a couple of things to note here. Since you need to be able to network boot your boxes, your DHCP server has to know the alternate location to send the netboot clients to. This is briefly described here. Also note, if you had a MySQL server installed before you added FOG you’ll need to modify the /var/www/fog/commons/config.php file to reflect the MySQL root password.

If you direct yourself over to http://localhost/fog/management. You can then use username: fog and password: password to get to the status/home page:

I would suggest adding a new user to do the management work. You can get to the user management page by clicking on the icon next to the ‘home’ icon in the toolbar (second from the left), click New User in the left hand menu, entering a username and password  and then clicking Create User.  Next, you’ll want to add some hosts. Click on the icon that has a single monitor (third from the left), click Add New Host, and then enter the hostname and hardware address of the Windows machine you wish to image. If you don’t know the hardware address of the host you want to add, and are on the same network you can look it up using the arp table.

First, ping the host (using your hosts ip in place of the 192.168.0.101) to make sure it is alive. Then check the arp table:

~$ ping -c 1 192.168.0.101
~$ arp -a

After adding a host successfully you should see something similar to this:

Since I didn’t have much space on my image server to begin with, I modified the default storage node to point to a samba mounted filesystem on my fileserver. This is where you’ll store all of your backup images. Since this can get big pretty fast, you’ll want have lots of dedicated storage. You can modify the aforementioned settings by clicking on the Storage Management icon (the sixth icon from the left).

Now we need to add an image. You can do this by clicking on the icon labeled Image Management (the fifth icon from the left). Click New Image, enter in a name, select a Storage Group, an image filename, and then select the type of image to be stored (Single Partition, Multiple Partition, Multiple Partition all Disks, or RAW). As far as the server management goes, you are done. Before uploading drive images to the FOG server, though, you will need to install the client package on the machine you wish to image. that software can be obtained by going to http://[fog server]/fog/client.

Overall, I found the interface fairly intuitive. I would have given it a very intuitive rating had the advanced host tasks been easier to find. I mean, this is one of the really cool features of FOG and the amount of tools that it packs is enough to blow your socks off. If you click on the Tasks Management Icon ( the Star ) on the main site, click on List All Hosts, and then click on the little Advanced icon you get a chance to see what I’m talking about. There are a slew of great utilities to run on the host:

• Debug features for Uploading and Deploying images
• Memtest86+
• Wake-On-Lan
• Fast Wipe (destroys MBR)
• Normal Wipe (one pass zeroing out data)
• Full Wipe (writes random data over a couple full passes)
• a Disk Surface Test
• Test Disk
• Recover (using PhotoRec)
• Antivirus (using ClamAV)
• and a Hardware Inventory Utility

If you are looking into how to maintain a small to large amount of computers in a SMB or campus setting, you really should consider checking out FOG. Leveraging the best of Open Source you’ll be able to easily deploy standard images to loads of computers in a minimal amount of time. You can even manage computers using your iPod or iPhone!

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

To install, you can grab the source code, or use apt:

~$ sudo apt-get install fail2ban

Next we need to modify the config files to suit our needs a little better. Go into your /etc/fail2ban folder and make a copy of the jail.conf. Name it jail.local:

~$ cd /etc/fail2ban
~$ sudo cp jail.conf jail.local

There are a couple of things I want to change from the default settings. The first would be increasing the bantime from 10 minutes to an hour. Then I want to change the max number of tries to 3. This will go for all services that are currently protected by fail2ban. So, lets go ahead and edit the [Default] section of the jail.local that we just copied to look like this:

[DEFAULT]
# "ignoreip" can be an IP address, a CIDR mask or a DNS host
ignoreip = 127.0.0.1
bantime  = 3600
maxretry = 3

Now lets give it a go! Save the file, and lets restart the fail2ban process.

~$ sudo /etc/init.d/fail2ban restart

For the sake of the article I’ve tested the setup, and you can see what I’ve found. In the top screenshot below I tried logging into my local ssh server, and in the bottom screenshot you’ll see the fail2ban.log and auth.log’s tailed output from the SSH server.

Normally, I don’t think a box on my network is going to fail authentication a bunch of times, or, rather, I don’t want to ban any boxes on my network.  What do we do? If you go back into the /etc/fail2ban/jail.conf file, you should notice the ignoreip option. You can modify this file again to ignore all bans for a 192.168.0.x IP by setting this option:

[DEFAULT]
# "ignoreip" can be an IP address, a CIDR mask or a DNS host
ignoreip = 127.0.0.1 192.168.0.0/24
bantime  = 3600
maxretry = 3

Save the file, and restart the fail2ban process again, and you are in business. This should keep script kiddies and brute force attacks away. Happy Hacking!

I’ve recently ran across a unique little backup utility called Mephisto. The program is a command line tool written in Java that incorporates rsync and tar to do filesystem backups to a remote filesystem or local image. Of course utilities like this are great for doing system duplication, and especially great when you roll your own LiveDVDs for disaster recovery or general backups. To backup to a remote server you’ll first need to copy over your ssh id (the utility has a little information on that when you go to create a configuration file), and then create a configuration file with the specs for your remote fileserver. I had a chance to test the remote sync feature from my laptop to a ssh server, and while the utility is a little rough around the edges it does function well. One thing that drove me a little nuts was the lack of a status bar during file transfer. While the utility does have a little room to grow, I think this is a pretty good starting point and definitely a great piece of Java code to disect.

You can grab a copy from the blog site in two flavors: one including a JRE or one with just the base program. Check it out, and let us know what you think!

While Parallels and VMWare offer commercial solutions, Sun backed VirtualBox offers many similar features for free. As mentioned before, however, stability issues have kept me from using it on my Macbook. After having some time to play with this new .1.2 update, I’ve found that most of my previous issues have been resolved. I haven’t experienced random crashes, and I was successfully able to boot OpenSolaris 8.11, Ubuntu Intrepid Ibex, SymphonyOne, and PC-BSD with no hiccups. I even managed to get through almost all of the ESXi bootup disk (a task that would fail within seconds before)!

I have been very happy with VMPlayer on my Linux boxes, but felt the lack of a viable free solution for Mac OS X. After a couple of hours, I think I can safely say that Sun contributed greatly to this very impressive, and free, application. I also wasn’t too disappointed in speed considering my Macbook didn’t grind to a halt when starting up Majong. So, if you need a quick virtualization setup that has all the tools to get a guest system installed in one go, then you might want to try VirtualBox.

Check out the latest release, and let us know what you think! Here are some of the screen shots from my experience:

So, my very basic problem was this: I want to search the current directory, and list all the files and folders in the current directory recursively. If you are familiar with bash shell scripting, you’ll know that this task is pretty basic and can be completed with the following:

#!/bin/bash
for i in $(ls -R ./)
do
  echo "$i"
done

So, why Ruby then? Well, bash doesn’t have all the wonderful pieces of Object Oriented goodness that Ruby does, and most specifically I couldn’t easily tell Bash to spit everything out in an XML file. Besides, this was good practice preparing me for doing production level scripting. To get started, you will need Ruby, so if you are on Ubuntu your life is pretty easy. Just run this command in a terminal:

~$ sudo apt-get install ruby

Now, create a file called listing.rb and put the following in:

Dir.chdir("./")
for i in Dir['**/**']
 puts i
end

You can run this script by doing the following:

~$ ruby listing.rb

This should work exactly as the bash script above did. So whats so great? Lets go on adding a method call that accepts a directory, and allow a user to input the directory they wish to list. Modify your listing.rb file to look like this:

 def search(dir)
   Dir.chdir(dir)
   for i in Dir['**/**']
     puts i
   end
 end
#Start of the script
dir = ARGV.shift
search(dir)

If you are unfamiliar with how Ruby handles command line input, the ARGV variable is an array that stores all the arguments a user can specify. Since this is a Ruby array, the shift method will cause the first argument to be popped off and stored in the variable dir. Moving along, let’s see the output this produces. Remember now that this script requires an input directory to be given. To run it you can enter the following:

~$ ruby listing.rb ./

You should see, again, output that shows at least your listing.rb file, and one entry for every other file in the current directory. In both forms of the script I used the Dir[**/**]. The **/** says to match all files and all folders, so if a directory exists in the folder I specified the script will proceed to list the files and folders in that directory. To get an idea of what I mean, try running this command:

~$ ruby listing.rb /etc

Now that we can list a ton the files, how should we store them? That is a bit more of an intermediate topic for another day. For now we can muck around with the Dir class to limit our output. Try changing the **/** to something else, or using wildcards to match something specific in your folder. Try it out, and let us know what you think!

The idea behind 0Install is to give the ’standard user’ install privileges without compromising a system if malicious software is installed. While this is cool for the user, it is even cooler for the application developer. As you might know, package maintenance can be both tedious and time consuming, but 0Install offers to ease that by giving you a useful tool to easily deploy your app on any distribution. In other words, instead of needing to be “blessed”, as the author states, “by a distribution,” all you need is a URI to give to your potential user. If the user has 0Install on their system, all they need to do is drag the URI onto the 0Install application, and install. This can be done regardless of distribution, and regardless of the package manager employed by the system.

Of course, the cautious may ask about system security, and rightly so. I mean, it is true we don’t want our less knowledgeable users installing applications that could potentially harm our rather big 100+ user system! Instead of taking one package and making it available to everybody on the box, 0Install protects the system by using that URI as a unique identifier.

In a traditional system, “if one user installs the Gimp from http://evil.com then it might save the executable as /usr/bin/gimp. Another user might run this, thinking it was from http://gimp.org.”

Different from how the traditional system works, 0Install relies on the aforementioned URI to determine which application to run. The user that installed from http://gimp.org will never run the binary from http://evil.com because of that URI protection. Of course, the caching system is also smart enough to be space efficient, and not continue to cache applications of the same URI. These features can greatly increase security and ease of deployment while providing better software for users. The 0Install system supports Linux, FreeBSD, Solaris, and MacOSX (using MacPorts), and offers a tutorial that goes through the explaination of how to convert an existing binary tarball into a 0install feed. Check it out, and let us know what you think!

You can see QT in commercial use by major companies like Google (Google Earth Pro), Netflix (Roku player), and even Adobe (Adobe Elements). It currently supports two languages: C++ and Java, and has an Eclipse plugin for both languages. If you want your new concept or production app to reach audiences on Windows, Linux, and Mac, you may want to consider QT as your platform. You can grab the current 4.5 beta here. Check it out and let us know what you think!

Since speed was always an issue in 1.8 I figured I’d re-run my fib.rb script to find the fibonacci number for 35.  I ran it against ruby 1.8.7 (2008-08-11 patchlevel 72) and 1.9.0 (2008-06-20 revision 17482), the standard versions for Ubuntu Intrepid Ibex.

Here’s that 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

The test machine is fairly old, which makes it a good candidate to see the speed improvements. It is an old 1.8 GHz P4 with 768MB RAM running KDE4. Here’s what I got:

~/Code/fib$ ruby1.8 fib.rb 35
starting fibonacci
This might take a bit....
14930352
Finding the fib of 35 took:
97.311404
seconds
~/Code/fib$ ruby1.9 fib.rb 35
starting fibonacci
This might take a bit....
14930352
Finding the fib of 35 took:
11.752508888
seconds

Now, it is no news that 1.9 is faster than 1.8, but an 8x improvement on this simple recursive script? I was astonished! This is better than using XRuby to speedup Ruby performance!

To get started, lets setup the database. If you have Ubuntu, but don’t have MySQL installed run this in your favorite terminal emulator:

~$ sudo apt-get install mysql-server

During the install, it will ask you for a root password, this is what you use to admin your server so choose something you’ll remember. After that finishes, we can create the database. First, download the carlot-sql.zip file to your home folder. Now lets unzip it, and build the cars table:

~$ unzip carlot-sql.zip
~$ mysql -u root -p < carlot.sql

When prompted, use the password you gave during your MySQL install. If you followed along with the first article, and already have the database setup up you will need to make one change. Each row must have a unique, identifiable object so that Hibernate can keep track of them. Currently the cars table doesn’t have this so we will need to add a column that is a BigInt with name Id, not null, auto increments, and is the primary key. You can make this change by getting into a mysql command prompt and issuing an alter command:

ALTER TABLE `carlot`.`cars` ADD COLUMN `Id` BIGINT
NOT NULL AUTO_INCREMENT AFTER `VIN`,
ADD PRIMARY KEY (`Id`);

Note: Keep this step in mind when you are trying to use Play! with an existing database.

Next you’ll need to grab a copy of the Eclipse project file carlot.zip and import it as an existing project into Eclipse. Last, make sure that the Play! framework is in your path (documented in the first post), and now we can begin!

Using the Persistence feature we can change quite a bit of the current code and even remove a whole class from the project, specifically the CarLot class. Initially, that class served as a way of connecting to the database, grouping, and storing a list of cars to be handed over to the view. We can cut this out entirely and let the framework to take care of all database ugliness. Lets get started by removing the CarLot class from the project. Next modify the Car class to look like this:

package models;

// Round 3
import javax.persistence.Entity;
import javax.persistence.Table;
import play.db.jpa.JPAModel;

@Entity
@Table(name="cars")
public class Car extends JPAModel {
	//vars that make a car
	public String make, model, vin;
}

You will see that the Car class now extends the JPAModel giving the class all the necessary properties to be correctly managed. When the Play! framework sees the @Entity annotation it will do all the grunt work of keeping track of the Car objects by starting a JPA EntityManager. Now we can find, update, delete, and a whole lot more to these Car objects stored in the database through that Entity Manager.

Since we are working with a pre-existing database, I had to specify the @Table(name=”cars”) annotation to tell the framework which table we are working with. Had I not specified the annotation, the Play! framework would have modified the CarLot schema to have an extra table called Car (assuming the username specified in the application.conf file had sufficient authorities).

Moving along, we will now need to modify the Application class to look like this:

package controllers;

import play.*;
import play.mvc.*;
import play.libs.*;
import java.util.*;
import models.Car;

public class Application extends Controller {

	/**
	 * Default action.
	 * renders the app/views/Application/index.html template
	 */
	public static void index() {
	    List cars = Car.findAll();
	    render(cars);
	}
}

Now, in your project open up the eclipse folder, right-click on CarLot.launch, and select Run As CarLot. You can access your page at http://localhost:9000, and should see something similar to this:

We forgot to tell JPA that we are using the MySQL dialect. Open up your Application.conf file in the conf/ folder and uncomment the jpa.dialect=org.hibernate.dialect.MySQLDialect line:

# JPA Configuration (hibernate)
# ~~~~~
#
# Specify the custom JPA dialect to use here (default to guess) :
 jpa.dialect=org.hibernate.dialect.MySQLDialect

Stop the server by clicking on the terminate button in Eclipse, and re-run the application by right-clicking on the CarLot.launch file and selecting Run As CarLot. You should now see something like this:

In under 35 lines of code (mostly auto-generated, and including comments!) we were able to connect to an existing database, grab values, display those values, and all without even seeing database connection code. If this doesn’t get you excited, I doubt much will. The Play! framework is very impressive, and far exceeds the declaration of “mak[ing] it easier to build Web applications with Java”. Check out Play! and let us know what you think!

For your reference, the Eclipse Project file is available.

Thanks for using the API!

Update #1: Since the article posting there have been a couple of suggestions for updating the tutorial to further take advantage of Play!’s features. I have updated the article to reflect those changes, and wanted to thank you those who sent in the suggestions!

Update #2: After finishing this article, you may want to check-out the followup article on how to use an even smaller JPA-enabled model to lessen the DB legwork even further.

For the example I will use a database, CarLot, that contains 3 cars stored with their make, model, and VIN. What I want to do is connect to the database, grab the cars, and simply display them in a standard html table. I will need to create a Model to grab the cars, and modify the Controller to tell what the view should render. Lastly, I’ll modify the view to show how to display the car objects.

To begin this example you will need an existing mysql installation and the jdbc driver which you can get on Ubuntu by issuing the following command:

~$ sudo apt-get install mysql-server libmysql-java

The setup script that runs during the installation will ask you for a root password. You can use whatever you like, but in practice it is more secure to use a password different from that of your superuser.

Now, create a new file called carlot.sql and put this in it:

CREATE DATABASE IF NOT EXISTS carlot;
USE carlot;

DROP TABLE IF EXISTS `carlot`.`cars`;
CREATE TABLE  `carlot`.`cars` (
  `Make` char(20) default NULL,
  `Model` char(20) default NULL,
  `VIN` int(11) default NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

LOCK TABLES `cars` WRITE;
INSERT INTO `carlot`.`cars` VALUES
 ('Ford','Ranger',123456789),
 ('Nissan','Altima',123456790),
 ('Toyota','Corolla',123456791);
UNLOCK TABLES;

You can then use this file to create the needed database by running:

~$ mysql -u root -p < carlot.sql
Enter password: <password specified during install>

Next we’ll need to install the Play! framework. Grab a copy from the download site and then run the following in a terminal (with the assumption that you downloaded the zipped file to your home folder):

~$ unzip play-1.0-stable4.zip
~$ sudo mv play-1.0-stable4 /opt/play

To make the framework executable without specifying the full path we’ll add the play directory to the environment path. You can do this by editing your /etc/profile as a superuser and adding the following line to the bottom:

export PATH=$PATH:/opt/play

Then run:

~$ source /etc/profile

The ‘play’ executable should now be in your path, and ready to run. We can finally create our project. Do this by running this:

~$ play create car-lot

This will create our project’s folder structure and configuration files in ~/car-lot. To make it easier to reference in the article, I will use <car-lot> to specify that newly created project directory.

Lets move on to the code starting with the Model. There are two parts to the model in this project: the Car object and the CarLot object. The Car object will have 3 private variables (make, model, and vin) that will be accessible through accessor methods. The CarLot database will be responsible for grabbing information from the database, and putting that information into a usable form (a Car object). Keeping these separate will allow us to expand in the future (like adding more features to a car or adding different tables to the CarLot database) without breaking the current application.

Go ahead and create a file called Car.java in your <car-lot>/app/models/ folder and add the following to it:

package models;
public class Car {

	//vars that make a car
	public String make, model, vin;

	public Car(String make, String model, String vin){
		this.make 	= make;
		this.model	= model;
		this.vin 	= vin;
	}
}

If you notice, this code doesn’t have the standard accessors (commonly referred to as getters and setters). You might even ask yourself why? If that’s the case you’ve just noted one of the cool features of Play! called Properties Simulation. This Properties Simulation is a great way to keep code clean without sacrificing the usability. You have full access to your variables without having to write superfluous code.

Moving along, create another file called CarLot.java inside your <car-lot>/app/models/ folder with the following:

package models;
import java.sql.*;
import java.util.ArrayList;
import models.Car;

public class CarLot {

  public static ArrayList getListOfCars(){
    ArrayList cars = new ArrayList();
    Connection connection = null;
    Statement statement = null;
    ResultSet resultset = null;

      try {
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        connection = DriverManager.getConnection(
                     "jdbc:mysql://127.0.0.1/carlot",
                     "user", "secret");
        statement = connection.createStatement();
        statement.executeUpdate("USE carlot");
        statement.executeQuery("SELECT * from cars");

        resultset = statement.getResultSet();
        while(resultset.next()){
	  cars.add( new Car( resultset.getString("make"),
                             resultset.getString("model"),
                             resultset.getString("vin") ) );
        }
        connection.close();
      }
      catch(Exception e){
        System.out.println("exception: " + e.toString());
      }
      return cars;
  }
}

Your Model for accessing the database is complete. Of course, though, there is another way of approaching this. The authors of Play! took database access into consideration, most especially due to models needing to store and retrieve data. The default project configuration file (conf/application.conf) has a special section for database configurations:

# Database configuration
# ~~~~~
# Enable a database engine if needed.
# There are two built in values :
#   - mem : for a transient in memory database (HSQL in memory)
#   - fs  : for a simple file written database (HSQL file stored)
#
# db=mem
#
# If you need a full jdbc configuration use the following :
#
# db.url=jdbc:mysql://localhost/test
# db.driver=com.mysql.jdbc.Driver
# db.user=root
# db.pass=
#
# Connections pool configuration :
#
# db.pool.timeout=1000
# db.pool.maxSize=30
# db.pool.minSize=10

lets modify this file to our needs:

# Database configuration
# ~~~~~
# Enable a database engine if needed.
# There are two built in values :
#   - mem : for a transient in memory database (HSQL in memory)
#   - fs  : for a simple file written database (HSQL file stored)
#
# db=mem
#
# If you need a full jdbc configuration use the following :
#
 db.url=jdbc:mysql://localhost/carlot
 db.driver=com.mysql.jdbc.Driver
 db.user=user
 db.pass=secret
#
# Connections pool configuration :
#
# db.pool.timeout=1000
# db.pool.maxSize=30
# db.pool.minSize=10

Of course we will need to modify our code in CarLot.java to reflect these changes. Go ahead and edit the getListOfCars() method to look like this:

	//Round 2
	// Let the Play framework help out by modifying your
	// database configuration in the application.conf file

	public static ArrayList getListOfCars(){
		ArrayList cars = new ArrayList();
		ResultSet resultset = null;
		resultset = DB.executeQuery("SELECT * from cars");
		try {
			while(resultset.next()){
				cars.add( new Car( resultset.getString("make"),
						resultset.getString("model"),
						resultset.getString("vin") ) );
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return cars;
	}

Now our Model is complete, incorporating some of the database features that Play! has to offer. Next we’ll need to setup the Controller to get the car data from the database and tell the View what to display using the render(Object) method. If you look inside the <car-lot>/apps/controllers/ folder you will see that an Application.java file exists. This is the default Controller class that Play! created for you. All of the controller specific code for this example needs to be placed in this file.

Edit the file <car-lot>/app/controllers/Application.java to have the following:

package controllers;
import play.*;
import play.mvc.*;
import play.libs.*;

//User added imports
import java.util.*;
import models.CarLot;  //needed to connect to the database
import models.Car;     //needed because these are the objects
                           //we wish to render in the view

public class Application extends Controller {
  /**
   * Default action.
   * renders the app/views/Application/index.html template
   */
  public static void index() {
    List cars = CarLot.getListOfCars();
    render(cars); //the cars list is what is sent to the view
  }
}

That should do it for the controller. We grabbed our list using the CarLot class, and told the View to render it. Now we move along to actually coding how to display this data.

Like the Controller, the Play! framework created a default View. That view is in the form of an index.html file located in the <car-lot>/app/views/Applications/ folder. Since all we want to do is display the Car objects in an html table we can modify the code from this:

#{extends 'main.html' /}
#{set title:'Home' /}

<h1>It works !</h1>

to something like this:

#{extends 'main.html' /}
#{set title:'Cars in the car lot' /}

<h1>Cars in Lot</h1>
<table border=1>
<tr>
<td>Make</td>
<td>Model</td>
<td>Vin</td>
</tr>
#{list items:cars, as:'car'}
<tr>
<td>${car.getMake()}</td>
<td>${car.getModel()}</td>
<td>${car.getVin()}</td>
</tr>

#{/list}
</table>

You should be able to see that object referencing is quite easy, as well as setting up an iteration over the car list grabbed in the controller. Go ahead and save this file. Open up a terminal and run this command to deploy the application:

~$ play start car-lot

Direct your browser to http://localhost:9000 and see what you get. It should be something similar to this:

That’s not quite what we wanted. Well, there is one last change we need to make. We need to specify the default route, and you can do this by modifying the routes file located in the <car-lot>/app/conf/ folder. All that you need to do is change this :

# Uncomment this default route to start !
# GET        /                                Application.index

to this

# Uncomment this default route to start !
 GET        /                                Application.index

This route establishes where to send those objects put in the render() function.

Refresh your browser and you should get something similar to this:

You now have a customized web application that accesses a database and displays the contents in under 75 lines of code including the database schema!! This line count could be trimmed even more by cutting out the Schema altogether using the amazing Hibernate integration through JPA. This feature is described a little more in the online documentation on Play!’s website.

Cool… beans?? Sorry, I had to…

Go ahead and stop your server now by running:

~$ play stop car-lot

What about tools or IDE’s that can be used to help speed a projects creation? Wonder not. As I had mentioned in my previous article, the Play! framework has special commands to convert your project into an Eclipse or Netbeans compatible project. To make this particular project Eclipse capable, run:

~$ play eclipsify car-lot

Then import into Eclipse using the “Existing Project” selection:

Needless to say the project should be imported in all its hierarchy goodness:

You will see a couple more folders that you didn’t originally have when you ran “play create car-lot”. Some are Eclipse specific folders, but one of them is pretty cool. In the eclipse folder of your hierarchy you’ll find a bunch of .launch files. If you select the project’s main launch file (CarLot.launch) and then go to Run -> Run your server will be initialized and started! Refresh your web browser and everything should be there. You are truly ready to rock and roll with this framework. Just note, if any Eclipse configuration files are changed you are required to re-run “play eclipsify car-lot” on your project (now located in your eclipse workspace). That should get you going use the Play! framework. Check it out, and let us know what you think!

For your reference, a download of this eclipse project is available.

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.

Pretty great if you ask us… immediately after you be-friend someone, your screen refreshes and you are given a link right under the notification to Block the user… the one you just got done be-friending.

I feel bad for all the bi-polar folks that will be using this app, it’s just not fair…

What I didn’t want to do was define all the possible combinations of the base-style and extended-styles in the CSS file so I could just apply the one I needed depending on the logic in my application… I just wanted the base-style applied and then depending on some additional criteria, I wanted to apply some additional styles ontop of that.

I’m not that great at CSS, and was completely bamboozled as to how I could do this until I ran across this post talking about how CSS inheritance works, and wouldn’t you know it, it’s as easy as you might have guessed.

The way to apply multiple classes to a single element is to simply list them off in a space-delimited style, more specifically:

<div class="baseStyle extendedStyle">

So yea… sometimes things are as easy as you had hoped. I was fully expecting that to either not be supported or be way more complicated.

It’s minor and I think overall (even this screen) that Mixx has an excellent UI across the site, I just got a kick out of reading that flow. Almost like Mixx didn’t think much of my story and would prefer if I would just buzz off

Well, for starters:

• Print is now a function invoked as print() instead of print
• Lists are no longer returned for well known methods (dict.keys(), dict.items(), dict.values()). Instead these methods return Views. map() and filter now return iterators instead as well.
• Ordering comparison operators now raise a TypeError Exception when the operators don’t have a “meaningful natural ordering”
• Long has been renamed to int so there is only one built-in integer type which behaves like the old long type.
• Expressions like 1/2 will return a float while 1//2 will give you the truncated behavior
• Binary data and Unicode use has changed. Python uses the concepts of text and binary data instead of Unicode strings and 8-bit strings. If your application is using these old concepts, you will be required to make modifications. Check the doc here

There have also been quite a few new syntax additions and some changes as well:

• Binary and Octal literals are specified as 0b0110 and 0o720 respectively. (this was present in 2.6)
• Keyword-only arguments have been added to function calls
• New annotations for functions and return values potentially help 3rd party libraries (the example they give on the Python website allows libraries to use this to improve help messages
• Nonlocal has been added for variables increasing scope but not making global.
• Extended Iterable Unpacking

Of course, this is just a small list of the over all changes, there is still a list of syntax changes and, furthermore, a list removals. You can check the full list here and the actual changelog for the down-and-dirty facts. So do these changes have a negative impact? For now, the Python website lists 3.0 as being 10% slower over 2.5, and stated that this is possibily due to the removal of small casing for small integers. Of course this is still an x.0 release and there is plenty of room for improvements so don’t let that dissuade you.

One thing to note for code maintainers, it was suggested not to write code meant to be runnable on 2.6 and 3.0. Due to the wide list of changes supporting both versions would will result in a “very contorted coding style.” All of that being said, the new version comes with a source-to-source conversion utility called 2to3 to help with getting up to speed on the latest and greatest. Check out the new release, and happy coding!

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!

I’ll admit that I’ve always had trouble with the Java plugin and Firefox on my old Windows XP SP2 desktop, Windows XP SP3 laptop and my Windows Vista SP1 desktop; for some reason, usually after a Firefox update the plugin will crap out and stop loading whenever I go to a page with an Applet.

Working with JDK 1.6.0_10 was no different.

Here’s a bit of info about my system:

• Windows Vista – SP1
• JDK 1.6.0_10 w/ Browser Plugin set as Default for all Browsers
• Internet Explorer 7 (latest)
• Firefox 3 (latest)
• Chrome (latest)

My Experience

When I visited the new JavaFX homepage with both Firefox and IE, I got the two following results:

… more specifically, in Firefox the video player (com.sun.mediaplayer.MediaPlayerApplet from mediaplayer.jar) did not load. On IE it loaded, but I sat and watched the spinning loading animation for about 20 secs:

and then another 8 secs of the actual media player loading (what I guess was the stream buffering) before the video started playing:

Seriously?

How many people would use YouTube, Vimeo, Break, etc. if every single time you visited a page you were faced with that type of loading experience?

Just to make sure, I hit Refresh on the page to see if it would come up instantly… and still no luck. The first Plugin splash screen spun for 9 secs that second time and then the buffering screen for another 4 before playing.

{smartads}

I have no idea how Flash avoids these long load times OR why it keeps working in my browsers… all my browsers… after an update and the Java plugin cannot. But I shouldn’t have to know this stuff — I should be given a fluid development and deployment platform to target my applications for and Sun hasn’t been able to do that for me with Java on the Desktop, Java WebStart or Java Applets — why is JavaFX any different?

NOTE: There is probably a Flash ad displaying on the left right here… you didn’t notice the page load delay because of it did you? You probably would have if that were JavaFX.

This was the entire reason Applets failed — slow load times. When you got to a page with an Applet on it back in the day, your computer locked up and ground to a halt. We complained about it for 12 years until we got the Java-at-boot-time service with JDK 1.6.0_10 and the rewritten browser plugin. What I’m seeing is a much reduced pause time compared to previous Java/Applet experience, but still not as fast as Flash.

It’s almost like Sun is content competing with itself (e.g. “We are 810% faster than previous Applet loads!”), which is awesome assuming anyone cared about the previous benchmark, and no one does; they’ve all moved onto Flash or JavaScript.

So instead of benchmarking and designing against the current preffered solutions, we are still getting sub-par deliverables when it comes to performance.

But, But, But…

I know, I’m going to get hate-comments for this. I’m sure Java 7.0 has additional enhancements planned, and the tooling support from NetBeans may be quite nice in the upcoming future — I’ll hold off absolute judgement until then. All I’m saying, is that with JavaFX 1.0, the user-experience from my end is not much different than Applets before it… I’m still not enticed to deploy a product on this platform. Is this the best Sun can give me as far as a product-platform goes?

Also, how come the Sample Gallery is all written using AJAX and the individual sample pages (e.g. BrickBreaker) all require the samples fire off using WebStart? Did anyone else expect this to be done with JavaFX Applets besides me?

NOTE: These are some of the nicest example app/source code samplings I’ve seen for an API, I’m not knocking that quality.

Closing Thoughts…

It’s about two things:

• Convenience (for the user primarily and the developer secondarily)
• Performance

It’s always been about those two things. Unfortunately JavaScript and Flash dominated the first point and caught up with the second point (with JavaScript getting huge boosts with JavaScript VM work going on) while Java missed the first point for 10 years, and got about 80% of the way in the second point only this year — while the 1st point still isn’t totally solved with the JDK 1.6.0_10 release — there are still plugin/browser problems and you cannot begin to compare the “convenience” and widespread deployment of JavaScript engines or Flash to Java.

These are the reasons I’m not excited.

If JavaFX had shown me either of the following:

• Drop-dead-easy plugin installation in all browsers
• Flash-like performance with seemingly instant-app-loading

I would have been excited…  I haven’t seen either of those things yet. It really seems like JavaFX is a reboot of a failed paradigm/technology: The Applet. That didn’t work in the past, is it really going to work now?

Success Obviously Still on the Table

There is obviously still a possibility that JavaFX comes through (otherwise Sun wouldn’t be pouring so much into it), these are the hot-ticket items I see dragging it from the realm of “Applet 2.0″ into the realm of “Alternative to Flash”:

• Resilient Plugin – Stays hooked into your browser as well as Flash
• Performance Boost – Besides an ignorable pause, loads up with the page the first time, and no perceivable wait on subsequent JavaFX-enabled-page views (just copy Flash here… go look at YouTube)
• Visual Designers – Not sure what NetBeans plan is here, but this will be a must.
• Simplified Deployment Creation – Again, on NetBeans’s plate and not sure what is planned here.

Those items are in order of importance. You could have the best developer tools in the world, but if your end-user experience is still iffy, companies aren’t going to buy in, etc. etc.

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 wanted to have access to your personal music collection from anywhere on the road Sockso Personal Music Server just might be the answer you were looking for. All that is required for the installation is Java and a Windows, Linux, or Mac box to run the server on. The software has both a GUI for controlling the server, and a web interface for accessing your music remotely.  The software seems pretty robust, and is incredibly easy to set up.  Inside the zip file there is a batch file for double-clickability in Windows, a shell script that needs to be made executable for Linux or Unix, and an executable Jar for double-clickability in Mac OS X.

Both the web and server gui interfaces are pretty straight forward, and have quite a few features.  The server gui allows you to add Collections of music, create playlists, restricting access to users or to features like uploading music, and it even gives you the ability to specify an encoder for re-encoding your music for slower connections or for compatibility.

The web interface can be seen below with the Sockso flash player along with a view of the Sockso server gui in Linux, and a custom playlist.

If you’ve ever wanted a quick, easy way to setup a music server, or to just be able to have access to your personal music collection while on the road, Sockso might be a solution worth looking into.  It is lightweight, multi platform, and easy to use.  Just be sure to forward port 4444 from your router to your Sockso server, start up Sockso and you are good to go.  I haven’t seen an easier Open Source and multiplatform solution yet!

Check it out and let us know what you think!