Kungfuice.com » Computers

Tail Recursive Algorithms In Scala

kungfuice — Thu, 18 Sep 2008 16:56:38 +0000

< ![endif]–>After the NFJS conference this weekend I have been spending more and more time working in Scala and trying to learn the ins-and-outs of the language. One of the neat things I came across was tail recursive algorithm optimization within the language itself.

When writing in a functional language like Scala you rely heavily on recursive algorithms to do your work, instead of iterative algorithms more present in OO languages like Java. This leads to an interesting problem with running functional languages within the JVM.

The Java Virtual Machine does not have support for tail-recursive algorithm optimizations. What does that mean? Basically the JVM cannot spot when to optimize calls stacks for recursive algorithms. Well who cares right? If you’re writing in Java this issue doesn’t usually come up since most of us simply write our loops and are happy with the performance the JVM offers us.

However, when you are writing a lot of recursive algorithms you quickly start to see how tail-recursive algorithms help makes your code more efficient.

For those of you who don’t remember what a tail-recursive algorithm is, here is a short little explanation:

“A Tail-recursive function is a function that ends in a recursive call to itself (effectively not building up any deferred operations). Tail recursive functions have the ability to re-use the same stack frame over and over and therefore are not bound by the number of available stack frames. Many people have written the simple factorial function recursively, but many have noticed that if you pass it a value of N that is large enough you will see a dreaded Out of Memory exception.

The reason for this is due to the factorial functions deferred operation statement that comes at the end of the method. Let’s look at the simple factorial algorithm

//INPUT: n is an Integer such that n >= 1
int fact(int n) {
   if (n == 1)
      return 1;
   else
      return n* fact(n-1);
}

H You can see that at then end of the algorithm we have a deferred operation of multiplying n with the next value computed from factorial, this goes on and on until we finally hit a factorial function that returns one, at which point the stack is popped and everything returns nicely. However we are now bound by the available stack frames in terms of computing n (Also by the max size of an int, but that’s beside the point).

In a tail-recursive algorithm you do not see this deferred execution, and therefore the same stack frame can be reused over and over again. Here is the same algorithm rewritten using a tail-recursive algorithm.

//INPUT: n is an Integer such that n >= 1
int fact(int n) {
    return fact_support(n, 1);
}
 
int fact_support(int n, int acc) {
    if (n == 0) return acc;
    else return fact_support(n-1,acc*n);
}

As you can see there are no deferred operations in this example we have effectively gotten rid of having to use n number of stack frames. Each call to fact_support brings with it the current accumulated sum, and thus does not need to wait to “pop” the stack and rely on the stack pop to accumulate the sum of the factorials.

As you can see tail-recursive optimizations are very important to languages where recursion is relied on heavily. Without this type of optimization many of the recursive algorithms are now bound by the number of available stack frames.

So that can’t be so hard right? Why not just write all your algorithms to use tail-recursion? Well for one it’s not always possible to do this, but also it puts a lot of work in the hands of the developer. We have this beautiful thing called the JVM that should be able to spot cases where optimization can occur.

Unfortunately the JVM doesn’t know how to spot this optimization, therefore the Scala compiler must look at ways of optimizing your code. Even more unfortunate the Scala documentation explicitly states that you should not rely on the Scala compiler making this optimization.

It may optimize your code, but it may not as well, so really the only way to be sure is to write your algorithms guaranteeing that tail-recursion is being utilized from the get-go.

It would be really nice to see the JVM improved to allow for this type of optimization to be done in the Hotspot, and there has been talk about improving the JVM to support functional languages, but I guess time will only tell.

No Fluff Just Stuff Boston 2008 Overall Review

kungfuice — Tue, 16 Sep 2008 12:32:54 +0000

I’ve spent my weekend in Boston at the local No Fluff Just Stuff conference and I figured I’d write a little summary of what I observed and learnt over the weekend.

To start this was my first conference that I’ve attended besides some small ones while in College and University, and I have to say that it was both exciting and disappointing.

Heading into the weekend I was very excited to hear Brian Goetz and Ted Neward give talks about cool things like Java Concurrency, The Java Memory Model, Hacking the JDK, Scala etc, and I expected most people at the conference to be of the same mind set.

I found through talking with many attendees that most people seemed to share a different set of values as to what was important to them. I found this to be very interesting as it really showed me the difference between people who are developing for the “Enterprise” or big business and people like me who develop more for a technology based company.

When I heard people talking about Groovy and Grails I couldn’t understand why anyone would be so interested in a language that performed as poorly as Groovy (Yes I know it’s been getting better but when you start from incredibly slow, and move to just being a little less incredibly slow I hardly see this as an improvement) I started to see that there really is a difference between the enterprise developer and the developer.

I think this was an amazing aspect of this conference is that it really opened my eyes to the other side of the coin, to the developers that work hard to create the applications that we use every single day from our Banks, Insurance companies etc and the different set of requirements that their applications have to deal with then what I’m used to.

I also have to say that after this weekend I am VERY VERY glad to be working where I am. Some of the horror stories I heard from people as to how they have to work, the lack of tools support that they face, and an overall management’s lack of letting things change made me cringe in pain and a few times I just wanted to give them a hug to tell them that it would all be OK (Yes sometimes it really was that bad like the guy who told me they were still using Java 1.4.2 because his boss thought if it works don’t fix it!)

So after sitting back over the weekend and getting over the initial culture shock that I faced meeting a lot of these developers, I have to say that this conference helped me in a way I never thought it would.

Sure I learnt all about the Java Memory Model, and how I can modify byte code on the fly with tools like BCEL, but more importantly I learnt what other developers have to go through on a daily basis and what it’s like to be an Enterprise developer in the real world.

All I have to say to that is, thank god I don’t have to deal with that shit every day. Overall though I definitely would recommend this conference to someone working in the Enterprise world, I definitely got value out of it though with my talks with Brian and Ted and I have to say that if they weren’t there this show definitely would of been a wash for me. So thanks Brian and Ted for really opening my mind and eyes to some cool new ways of doing things.

Picked up some new books

kungfuice — Mon, 01 Sep 2008 18:49:23 +0000

Last week I finished the book “Prelude to Foundations” by Isaac Asimov. It was recommended to me by my boss, and I have to say it was one of the better books I have read in a while. I usually try to switch up reading technical books with non-technical books, and since I haven’t read any new technical books I decided to head over to chapters and pickup some new books.

I have head great things about both Java Concurrency by Brian Goetz, and Effective Java 2nd Edition by Joshua Bloch. The real problem with both these books is they are hard to find in store. I happened to come across both of them at my local Chapters, and quickly snatched them up.

I have been reading Java Concurrency over the past couple of days and I have to say this is one of the best Java books I’ve read in a while. Brian Goetz has a way of writing that really helps bring complex problems into perspective.

One of my initial gripes about this book was the lack of exercises at the end of the Chapters, however now that I’m a little ways into the book I’ve noticed that the examples chosen for each Chapter progress almost as a set of exercises in themselves. Not to mention that Brian picks examples that relate well to the real world, instead of most of the silly easy examples found in other books I’ve read.

I would definitely recommend this book to anyone looking to delve into the world of Java Concurrency, or even someone looking to freshen up on the latest stuff available in JDK 1.5 in terms of threading. This book has really helped me in my pet projects and in my day-to-day work so I would definitely recommend getting it and keeping it close by.

I’ve yet to really get into Effective Java, but the little bits I’ve read here and there have really shown me that this this book lives up to all the hype about it. Joshua is a smart man, and this book definitely reflects his intelligence. It is well organized and shows you things about Java that you never thought even existed. I’m really excited to delve deaper into this one.

I’ll write a more thorough review once I’m finished with it. Anyway until next time …

Finally a new PC!

kungfuice — Fri, 30 May 2008 03:08:50 +0000

Well I finally broke down and decided it was time to upgrade my old PC. To be honest I couldn’t of asked for a better computer, I’ve had it since 2004 and it’s cost me nothing but a new hard drive once. To me this is prove of why I always tell people the best computer money can buy is the one you build yourself.

Sure you can walk into your local Futureshop or PC Shop and get a pre manufactured/assembled PC, but you have zero guarantee as to what is inside of that PC. In most cases large manufacturers use subpar components in order to keep prices competitive. Small PC Shops are notorious for advertising certain components but giving you low cost alternatives in the final product, not to mention that their computers are usually more expensive then just buying the parts yourself.

As I’ve always built my own computer, this time was really no different. I had been toying around with the idea of buying a Mac Pro, but I just couldn’t justify the cost, not to mention that I’ve been successfully running OSx86 for months on my PC. In order to continue doing so I had a couple of requirements for my new PC which seems to be a theme of mine as of late.

First my new PC had to be power efficient. I find myself becoming a lot more eco-friendly, and I feel that having a PC that is efficient can really help to reduce everyones carbon foot print. This leads to my second requirement, which was my number one requirement in my previous PC, the computer had to be QUIET.

If there’s one thing I hate more then anything else, it’s having to listen to the hum of 5 fans churning away inside someone’s PC. I don’t understand how people live with this. I spend a good amount of time next to my computer, and the last thing I want is to have to listen to fans.

My previous PC utilized a lot of power efficient components that I could passively cool, in order to minimize noise. I also made use of one of my favourite cases the Antec Sonata II this quiet case included a lot of ducting to help air flow and minimize the number of fans needed to cool your components. It also came with hard drive shock absorber mounts, and a heavy aluminium construction to eliminiate vibration noise. Unfortunately the interior ducting was also the most annoying part of this case, adding new components was a pain, and tucking wires became an issue as the ducting really got in the way.

My third requirement was that my new PC be built with components that I knew would last for at least the next couple of years. I’m a firm believer of paying money up front on solid top of the line components that I know will not be obsolete in a few months, and that are well manufactured.

With these three requirements in place I spent some time wrestling with what components I wanted to include, and where I was going to get the best price for these components.

One of my first problems was whether or not to splurge on a quad core cpu. I had really considered the Intel Quad Core Q6600, but after doing some reading (Especially this article over at Coding Horror) I really came to the conclusion that the Quard Cores would probably go to waste on me. Not to mention that the Quad Core uses a 65nm process, and definitely violates my power efficiency requirement.

After eliminating the quad core from my list of potential CPUs I had to decide what dual core processor I wanted and to be honest this wasn’t a difficult pick for me. The new Wolfdale based Core2Duo processors from Intel are power efficient and use a 45nm design which allows them to be overclocked to insane levels. These CPUs are only marginally more expensive then their 65nm counterparts, and since my local PC shop was having a sale on the Core 2 Duo 8400 I decided to pick it up for $190.

My next problem was choosing a suitable video card. I knew first that I had to choose something from Nvidia, as driver support for ATI based cards is abysmal in Linux, and OSx86. This somewhat limited my choices, and with so many high end gamer cards made me wonder if I’d ever find something to suit my needs. I really wanted something that was passively cooled, since in most PCs the bulk of noise originates from the Video Cards cheap fan. After doing some thinking and reading I decided that the highend 8800 series was out as it was difficult to passively cool and definitely violated my power efficiency requirement.

My next card was the 9600GT which I really did consider thoroughly. Gigabyte has a new passively cooled version of the 9600GT that I thought would make a perfect fit, however I couldn’t justify the $200 it was going to cost me. I am not an avid gamer, in fact that last game I ever played on my PC was Command and Conquer Tiberium Wars, not the most graphic intensive video game.

With these cards eliminated I stumbled across an ASUSTek Silent 8600GT, which seemed to fit my needs quite well. This card is passively cooled and does not require and extra power connection. This card was also on sale at my local PC shop, so I managed to score it for $75.

I now had to find a suitable motherboard to connect all this stuff too. I’ve always been fond of Asus motherboards and have been using them exclusively in my personal computers since 1998. I’ve yet to really ever have an issue with them, so it was obvious to me that I would be putting one in my new computer as well. My first job though was to verify what Asus boards worked best with OSx86. After doing some hunting around the web I found that the P5k-E series of motherboards had good compatability with OSx86, and were solid performing motherboards based on Intel’s P35 architecture. I found a P5K-E on sale at my local pc shop for $160.00.

Having my main components in hand, I decided that I’d have to get a new case to house my new components. I decided on the Antec P182. This case was designed with the help of SilentPCReview there are tons of reviews of this case on the net, so I won’t go into full details as to why I chose the case, but it definitely fit my needs, and fit my budget as well. I fitted the P182 with an Enermax Modu+82 525w powersupply. Unforutnately I couldn’t find a lower wattage powersupply. I would of prefered the 425W Modu+ 82, but things don’t always work out for the best. I’ll be keeping my eye out for something a little lighter in the future and will probably make the switch. I do have to say though, this power supply is incredibly quiet. Usually power supplies are always humming along, but with this one I barely even notice when the fan kicks in.

I filled the rest of my PC build up with the usual components, 4gb of ram (A definite requirement for anyone who does any type of software development), a DVDRW drive, and a Seagate NCQ 500GB hard drive.

Overall the new PC is everything I dreamed it to be. Finally my PC isn’t struggling to run Tomcat, MySQL, and Eclipse at the same time, finally Itunes loads in a reasonable amount of time, and most of all finally it doesn’t take me hours on end to Rip a DVD.

Here’s a final spec list for the build including prices for all the items

Bringing the grand total to $873.96!!!!

When you consider that the same PC from Dell or HP would cost you a lot more then that, it’s pretty satisfying to know that not only did you save yourself money, but you enjoyed yourself while doing it.

Java String Comparisons

kungfuice — Wed, 14 Nov 2007 13:49:31 +0000

Today I thought I would take some time to outline basic String comparison in Java. To many newcomers using Java doing comparisons using String can be confusing. Take for example the following piece of code which compares two String literals and two String objects. To newcomers of the Java language the following is confusing. Let’s take some time to outline how this actually works, and what actually makes it confusing.

01 public class Test {
02     public static void main(String[] args) {
03         String a = "abc";
04         String b = "abc";
05         String c = new String("abc");
06         String d = new String("abc");
07         System.out.println((a==b);//true
08         System.out.println((c==d));//false
09     }
10 }

First let’s look at the instructions used to generate a String literal in Java. It’s fairly straight forward for anyone who’s seen assembly before. We simply store the literal value using the instruction sets store command.

Instruction used to generate String literal
0: ldc #2; //String abc 2: astore_1

On the other hand there are many more instructions used to generate a String using the new operator. Since we are using the new operator we create a new reference to memory location, duplicate it, load the String literal and invoke a special init function on that new memory. In Java terms we are merely creating a new object and invoking that objects constructor with the parameter “abc”.

Instruction used to generate new String()
6: new #3; //class java/lang/String 9: dup 10: ldc #2; //String abc 12: invokespecial #4; //Method java/lang/String."":(Ljava/lang/String;)V 15: astore_3

So the question still remains, why does a==b return true, and c==d return false? First let’s look at the == operator itself. The == operator works on String object references. If two String references point to the same object in memory, the comparison returns a true result. Otherwise, the comparison returns false, regardless of whether the text has the same character values.

The == operator does not compare actual char data. So we know now that the == operator is looking at comparing two object references, but how can a==b be true?

Well this comes down to the different way Java handles literals. The Java platform creates an internal pool for string literals and constants. String literals and constants that have the exact same char values and length will exist exactly once in the pool.

Subsequent comparisons of String literals and constants with the same char values will always be equal. So you see we could create a million String literals with the value “abc” but Java would only have reference in it’s internal pool to a String literal with value “abc” and length 3.

On the other hand c and d are not String literals they are String objects, and therefore are not created in the Java String literal and constant pool. These objects will each have it’s own reference in memory and therefore will have different values for their references.

Using the == operator to check whether their reference points to the same value will never be true since each occupies it’s own slot in memory.

If we wanted to compare the actual values stored within the String instead of their references, we would simply use the equals method or the compareTo method.

I hope this helps clarify some of the mystery behind how Java handles String and I hope I have helped increase your understanding of String comparisons in Java. Next time we’ll take a closer look at Natural Langauge text comparison in the Java language.

Vista Plunge

kungfuice — Sat, 17 Mar 2007 20:10:23 +0000

Well over my reading week I decided to make the transition to Windows Vista. I had recently been running Ubuntu Edgy exclusively on my desktop, but decided that I wanted to see what Vista was all about. I picked up a copy of Home Premium (Legally!), and installed it on my box. I must say that I was very impressed with the changes to the Windows Installer. The image based install went smoothly and I was up and running in just over 30 minutes.

Once Vista booted everything just worked, I didnt’ need to download any drivers everything was done for me, which was a pleasant change from what I remember installing when I last installed Windows XP. Although Vista doesn’t have any services packs yet I think this will eventually change but we will see.

I was concerned about how my box would handle Vista, my computer is by no means old, but at the same time it’s definitely not bleeding edge. Currently I am running 1.86gz Centrino Processor with 1gb of PC3200 Ram, and an 80gb Sata Drive with a 120gb IDE storage drive, and I have an AGP 6600GT Nvidia Video card. Vista actually runs quite nicely on this setup. The overal experience seems very “snappy” everything opens quickly, and my memory usage is usually between 500-750mbs of my overall 1gb. I did however make the upgrade to 2gb recently just to give myself that extra “room” just incase.

Overall I really do enjoy the UI changes that have been made, and with the system in general. The search improvements are a blessing, and it’s nice to just type what I’m looking for in any window and have it just come up. Overall the Vista Eye Candy is nice, but is by no means as good as Beryl in Linux, however I do find that it is a lot more stable.

I really enjoy the integration of windows media player and the improvements they have made to it. I was always a fan of windows media player when I used windows. I liked it’s small memory footprint, library folder watching, the only thing I didn’t ever really like was the UI and they have definitely improved in that department.

All things considered if would definitely recommend anyone who is still running windows xp to go out and make the switch. I find that Vista has given me a reason to enjoy windows again, for now, but that definitely does not mean I spend a lot of time in it. I still use Linux as my main OS and would say I’m in that at least 85% of the time.

So yeah I guess that’s my pseudo review of Vista. I hope it helps some people make the decision to make the switch.

I almost forgot here’s a screenshot

What vi would look like if Microsoft had made it

kungfuice — Fri, 09 Mar 2007 04:22:36 +0000

What vi would look like if Microsoft had developed it

There’s no where to run and hide from the vi assistant!

Kill -9 White Geek Rap

kungfuice — Thu, 08 Mar 2007 15:45:56 +0000

Well I came across this absolutely hilarious video on youtube that really spoke to me. Maybe it’s the fact that I’m seriously going out of my mind from lack of sleep and stress, or maybe it’s because I’m taking an operating system course this semester so some of the things this guy spits really speak to me. Whatever it is this has to be one of the funniest, geek, gansta raps of all time. This guy’s name is Monzy and if you checkout youtube you’ll find a wealth of other just as funny raps. “I do a bounds check before I write to an array”! Foo!

Installing Flash Player 9 Beta On Ubuntu Edgy

kungfuice — Thu, 19 Oct 2006 03:06:33 +0000

OK finally Adobe has decided to release Flash Player 9 in Beta Form for Linux. I’ve decided to throw together a quick how to on how to install it on Ubuntu Edgy. This should hold true however for most flavours of Ubuntu as well.

Open Synaptic Package manager
Click on the search button and type “Flash”
Click the box beside any of the currently installed flash-plugins, this should be flashplugin-nonfree, and select for a complete removal
Now click apply and let Synaptic remove the package
We are now ready to download and install the flashplayer 9 plugin
Point your browser to “http://labs.adobe.com/downloads/flashplayer9.html”, and select the “Download Installer for Linux” link. Remember where you save this file because we’ll need it next. Close down your browser when you are done since we don’t want it open while we install the plugin
Open your favourite terminal and navigate to the directory which you saved the plugin, and execute the following command:

tar -vxzf FP9_plugin_beta_101806.tar.gz

You will now have a directory called flash-player-plugin-9.0.1.21.55 or something similar, navigate to this directory
You will now need to copy the library “libflashplayerplugin.so” to “/usr/lib/firefox/plugins/”, execute the following command:

sudo cp libflashplayer.so /usr/lib/firefox/plugins/

Navigate to your favourite flash enabled website and enjoy having the latest and greatest flash player.

I hope this helps, please post if you have any problems or further questions. I hope this helps everyone out.

Update …
TreviÃ±o from Ubuntu Forums was kind enough to pack the player into a package. You can now get the files from his repository at http://3v1n0.tuxfamily.org/dists/dapper/3v1n0/

Download the deb and install it

Get Rid Of Annoying “setkeycodes” Messages in Ubuntu

kungfuice — Thu, 12 Oct 2006 01:04:18 +0000

If you have been noticing messages in your logs about unknown key presses I’ve found a solution that gets rid of them.

I had been getting messages like this in my messages log and wanted to get rid of them

kernel: [17204628.240000] atkbd.c: Unknown key pressed (translated set 2, ode 0xd9 on isa0060/serio0).
[17204628.240000] atkbd.c: Use ’setkeycodes e059 keycode’ to make it known.

[17204603.280000] atkbd.c: Unknown key released (translated set 2, code 0×81 on isa0060/serio0).
[17204603.280000] atkbd.c: Use ’setkeycodes e001 keycode keycode’ to make it know.

These errors were randomly generated when I used any keys on my keyboard. There are documented cases of having similar problems with media keys on laptops but nothing to do with regular keys.

I decided that since I was not having any problems using my keyboard that I would simply assign these keys to some empty key code to appease the system.

This is how you do it:
Edit The File:”/usr/share/hotkey-setup/generic.hk”

sudo gedit /usr/share/hotkey-setup/generic.hk

Place these lines in the file, remember to use the values of the keys that appear in your logs, don’t just copy and paste

setkeycodes e059 254
setkeycodes e001 255

Now simply restart the hotkey init script by doing:

sudo /etc/init.d/hotkey-setup restart

Voila those messages should stop appearing in your logs