Babylon Candle

Firewall configuration with iptables

2011-11-22T14:47:00.020+10:00

Recently I had the seemingly "daunting" task of adding firewall rules through the iptables command. Here are some of my findings.

Basic Commands

To list your current firewall configuration use:

If you have no rules in your iptables you should see something like this:

To add a rule to a chain use:

To delete a rule on a chain use:

Make sure your firewall INPUT chain policy is set to ACCEPT not DROP.

Add some basic rules to the INPUT chain:

The above rules allow SSH, DNS, HTTP and HTTPS traffic. It also logs any requests that have not been satisfied by any of the rules to your syslog. We have also blocked all other traffic and ports.

List your iptable rules with:

Your iptables should look similar to this:

For some reason if I leave out the first rule, none of the others work. I presume this has to do with connections coming in on known ports but negotiating on to other ports once a connection is established.

The DROP policy for the INPUT chain drops all traffic to ports other than those specified in your rules. If there's no rule, it's not getting through.

Also of note is that rules are evaluated top-down with the first matching rule executed. Thus if you have a rule that drops traffic for a certain port followed by one that allows traffic for the same port, all traffic will be dropped.

Given the above, if you need to insert a rule at a particular line do so with the following:

Make sure you verify that all the programs you need are allowed through the firewall. If needed you can change the policy of the INPUT chain back to an ACCEPT policy like so:

One thing to note is that if you are some way locked out of your system due to the above rules, a simple reboot will remove all entries.

Save and Restoring Rules

As iptable rules are not saved and restored by default you need to it manually.

1. Save your current changes:

2. Create the file /etc/network/if-pre-up.d/iptablesload This will be run just before your network interfaces are brought up. Add the following:

make it executable with:

3. Create the file /etc/network/if-post-down.d/iptablessave. This will be run just after your network interfaces are brought down. Add the following:

make it executable with:

Now when you restart your machine your iptables will be saved and restored. You can have a look at the rules that are persisted by looking at the /etc/iptables.rules file:

Your /etc/iptable.rules file should look something like this:

Comments/suggestions are welcome. :)

Links: 1 2

Ensime with Emacs

2011-04-06T16:39:00.009+10:00

I've been toying with the idea of looking for an alternative to Intellij for Scala development for a while now. I tried to use Ensime with Emacs a few months ago and never got it going for one reason or another. More recently, I've got Ensime and Emacs working together and thought I'd blog about it for anyone else who had trouble getting everything to work together.

Here are the minimum requrements as stated on the Ensime user manual:

1.Unix(y) or Windows OS
2.JVM Version 6
3.Scala 2.8.1 compatible source and libraries
4.Emacs 22 or later (23 is recommended)

Configuring Emacs for Scala

1. Ensure you have a working installation of scala 2.8.1final.

2. Install emacs. On Ubuntu you can do this with

sudo apt-get install emacs

and on the Mac you can:

brew install emacs

Ensure you have at least version 22 or later.

3. Go to your scala_installation_dir/misc/scala-tool-support/emacs/ directory. Copy all .el, .elc files and the Makefile into a location where you want to store these files.

Eg. ~/scalaemacs

4. Copy the contrib/dot-ctags file to your ~/.ctags file

5. Using a command shell, cd to the above directory and run "make" to convert the .el files to .elc files.

6. Add the following to your ~/.emacs file:

eg.

You may need to create this file if it does not exist.

7. Open a .scala file in emacs to verify syntax highlighting works and other basic scala functionality works.

Installing Ensime

1. Ensime can be downloaded from here. Download the latest version. The current version is -> ensime_2.8.1-0.5.0.tar.gz

2. Extract the archive downloaded to a know location. This will be your ENSIME_ROOT.

Eg. ~/opt/ensime

3. Verify that the ENSIME_ROOT/bin/server.sh file has execute permissions.

4. Add the following to your ~/.emacs file substituting ENSIME_ROOT for where you extracted the archive:

Your complete .emacs files should look something like:

Creating a Project with SBT

You need to create an Ensime project for each project you want to use with Ensime. The project details are written to a .ensime file in your project root. Ensime currently has support for SBT, Maven and Ivy. If you don't have a build system you can also generate a .ensime file through the wizard or by hand.

The following is how to create a project for an existing SBT project:

1. Launch emacs
2. Type M-x to open the mini-buffer and then type: ensime-generate-ensime-config-gen.
A note on the Meta key (or M-) combinations: On linux M-x is Alt+x, while on the Mac it's Esc+x. Play around until you find which meta key is used on your flavour of OS.
3. Specify the root of your project.
4. If your project is an SBT project, it automatically detects most settings and you should see a message like:
"Your project seems to be of type 'sbt', continue with this assumption? (yes or no)". Choose yes.
5. Enter all the other information requested.
6. At the end you will see something like "Your project config has been written to /xyz/.ensime. Use 'M-x ensime' to launch ENSIME." Your ensime file has been written and you are ready to use ensime.
7. Type M-x and in the mini-buffer type: ensime to launch the Ensime server for your project. Reconfirm the location of your project.
8. That's it! :)

Neat Features

1. Type inspection - will dive into details of the type at the cursor
2. Automatic member completion (eg. typing "blah". followed by the Tab key will give you a list of the methods on String.
3. Navigation between sources
4. Refactoring (Renaming, Optimizing imports etc)
5. Source formatting
6. SBT support
7. Dropping files into the Scala REPL
8. Debugging (I haven't had much luck getting this to work)

For a full list have a look at the online Ensime user manual.

Functor

2011-02-16T12:24:00.024+10:00

What is a Functor?

Chances are you've already used a Functor. You probably use it everyday irrespective of the language you use.
Paraphrasing Typeclassopedia: "A Functor represent a container of some sort with the ability to apply a function uniformly to every element of that container".

Say we had a List of words and we wanted to find out the lengths of each of those words. We would use a List[String], find the length of each String and get a List[Int] in return.

In scala we could do something like:

We applied the length function to each element of the List "container". What has also happened is that a List[String] has been converted to a List[Int]. We started with a List of words and we end up with a List of word-lengths.

Functors operate on type constructors - which are types that need additional types parameters to be constructed. List[T], Map[K, V], Option[T] and Either[L,R] etc are all type constructors as they need one or more types to be constructed.

For example:

A functor can be defined as:

Assuming the F type constructor was List, the above trait could be implemented as:

All Functor implementations traverse over the type supplied and apply the function f, to each element within that type. In the case of List, f is applied to each element of the List.

We could use the ListFunctor as:

This gives us the same results as before, but we've abstracted over the List type constructor and we can covert from List[A] -> List[B] where A and B are any types.

Import points to note are:

1. The container remains the same (F or in the above case List)
2. The supplied function f, works on the value contained within the container.

As per Typeclassopedia: "fmap applies a function to each element of the container without altering the structure of the container"

Some Examples

Let's create our own type constructor to hold a single value. Let's call it Holder:

Now let's define a Functor for Holder:

Here's how we use it:

We converted a Holder[Int] -> Holder[String] by mapping across the value in the Holder.

Functor Laws

There are 2 Functor laws:

1. mapping with identity over every item in a container has no effect

2. mapping a composition of two functions over any item in a container is the same as mapping the first function and then mapping the second.

Let's see if HolderFunctor obeys these 2 laws:

Looks like it does obey both laws. :)

Why use Functors?

So here's the real question: Why use Functors? By defining Functors for each container you are interested in, you could define a single function that fmaps across any container containing any type:

Let's try and call it with Holder:

Let's create an implicit Functor[Holder]:

Let's try and use it with Functor[List]:

Let's create an implicit Functor[List]:

What if we want to use it with Option? We simply create an implicit Functor[Option]:

We can now call fmap with Option:

Verifying the laws for Functor[Option]:

We could further simplify fmap as:

Functor has allowed us to define a single fmap function to map across any container for any value type! :)

Here's a listing of the snippets:

Linux RAID Failed on Boot

2011-02-02T08:47:00.003+10:00

After upgrading from Ubuntu 10.04 to 10.10 I noticed that my machine refused to startup on most occasions. After a few reboots it eventually decided to startup. I am running a raid0 setup which includes the boot partition.

I got an error stating that "one or more raid devices were degraded".

The solution turned out to be a simple one. It turned out that one of the HDDs in the raid array took a longer time to spin up than the others. This difference only became apparent in Ubutun 10.10.

The fix is to add a rootdelay parameter to your /etc/default/grub file and update grub.

Edit your /etc/default/grub file and update the following line to include a rootdelay:


GRUB_CMDLINE_LINUX_DEFAULT="rootdelay=90"

You might need to increase your root delay if it still occurs after the above fix.

Update grub with


sudo update-grub

and you should be all good! :)

Lessons learned

2010-12-16T22:07:00.036+10:00

I have worked at a number of companies over the last few years. All of them start off looking good but most fall into the "I wish I hadn't wasted x years/months of my life here". "How did this happen again?" I've wondered. I naturally missed the early warning signs which I should have heeded. I've chosen to document some of the most frequent occurring warning signs and lessons learned in the hope of reminding myself to steer clear of certain Companies. I also hope that my lessons will aid you in not repeating them.

Ask better interview questions

Most developers never ask a prospective employer any useful questions. We might ask about technology. We might ask about the problem being solved. We negotiate salary. Rarely have I heard a developer ask more than that.

The interview is the best place to weed out jobs that are going to suck later. Just like in Kanban a problem is a lot easier to fix at the source of the problem rather than further down the process chain.

Here are some practical questions to ask:

1. Ask questions about the methodology. What happens when there are changes? What happens when new requirements are added? How are stories estimated? Who estimates them? How many stories were not implemented in the last couple of iterations?

2. Ask about the development process. This would include TDD, pair programming, integration testing, build systems, CI, the process by which artifacts are moved to production.

3. The technical interviewer is likely to be one of the more skilled members of the team. Find out about any technical books he is reading, opensource contributions, any new languages and frameworks he is using/learning and any conferences he has attended in the last few years. Is he constantly improving?

4. Find out how the position you are applying for became available. Are lots of people leaving the Company?

5. Ask about some of the technical challenges they currently face. Then ask about some solutions they have in place.

6. Ask about some improvements they have made between the last few iterations.

7. Ask them what the biggest hurdle to productivity is at the moment.

Don't be afraid not to accept a job, if you feel that the answers to some of the above are sketchy. It's easier to walk away now.

During one job interview, the technical teamlead mentioned things like: "40 developers have worked on the codebase in the last 4 years - and it shows", "I'm struggling to get the number of unit tests into double digits" and "the project is 4 years late but we will deliver it in 2 months". And both the teamlead and the team manager were only hired 2 months ago. Their predecessors had left the building. Needless to say I turned down this "amazing" offer much to the surprise of the hiring team.

Scrutinize the leader

The leaders of a company set the tone for everyone else. Who is a "leader"? It could be the CEO, the founder or even your manager. Have a good look at these people. They determine the ethos and care-factor of everyone around you.

An example is where I was interviewed by a CEO of a small IT Services' Company. He referred to his technical resources as "Nerds" and went on to say that he didn't know anything about Computers. He was also proud to say "We are not Google. We don't want to be anything like Google" and "We build Software. We are not building Rocket ships to the moon!". I should have run to the door and never looked back. Instead I proved to myself over the next few months that I should have indeed made that sprint when I could.

Here's what I should have learned from the above interview:

1. When CEO stated that he didn't know anything about Computers, he admitted that he knew nothing about the industry in which his Company was operating! Why was he running an IT company?

2. By calling people who understood his business "Nerds" he was happy to distance himself from the actual employees doing the work that made his Company money. He was also happy to be derogatory to a potential new hire and thought nothing of it.

3. He obviously didn't understand the complexities of Software. He assumed developing Software was easy. No big deal. Anyone who has worked in Software for more than 2 minutes knows different.

It's hard to escape from this kind of cluelessness. The CEO's attitude directly affects higher management. He continues to hire clueless people to run his project teams and they in turn hire clueless people to manage you and your team! Talk about a vicious cycle. When it all goes to pot (and it will) the "Nerds" aka you and I, get the blame. Needless to say the project I was on was in dire straits.

Standup for yourself

We've all worked at a Company where they want you to "hit the ground running". A friend of mine joined the Company I was working at. He was tasked with taking over the work of an experienced programmer who have been working on some secret squirrel project for the last few months. "Don't waste your time writing any tests" he had been told. He was a contractor. The Company had mishandled his contract and he had rightly found greener pastures. My friend was tasked with delivering the contractor's work in 3 days. He didn't have his computer set up. He had just walked in the door and he was already on a suicide mission.

My friend rightly said "No. I can't do it. I don't have the domain knowledge to get this done in 3 days". Pretty obvious and he didn't even have a working machine! He was met with resistance from the project manager. "Why not try?". But my friend rightly stuck to his guns and said "No. I can't do it. Get someone more experienced with the System to do it". After quite a lot of deliberating the project manager reluctantly agreed to shelve the changes and give it to someone else. "Wow!" I thought. It was refreshing to see someone standup for themselves. I myself might have "tried". I would have tried to get everything working as fast as possible. I would have had to cut corners. I would have worked late. Most heinously, I would have reinforced the fact that giving developers unachievable, impossible tasks was okay.

At another workplace I was repeatedly asked to work the whole weekend. The request came at 4pm on a Friday arvo just as I was leaving the building. I gave a polite "Sorry! Had you only told me earlier. I have plans" and walked off. The next week, the same thing happens. Around 4pm the same question. The same answer. It really didn't stop them asking and it didn't stop me giving them a flat "No". Had I been asked earlier I would have at least considered working the weekend.

It's all about respect. Obviously someone thinks it's fine to ask employees to sacrifice their entire weekend at the very last moment - for cash. Like people can be bought and used at will. This also goes to show the great planning around this project.

Rarely have I seen any developers standing up for themselves. We need to do it more and not accept the unrealistic expectations and pressure put on us. We need to be more professional. The more we do this, the better it is for us as a group of professionals.

Keep away from unethical people

Some Companies are happy to take large sums of their Customers' money and return utter crap in return. Testing is overlooked, shortcuts are taken. Everything is held together by ribbons. At one Company I worked at they were using their Customer as "first-level testing". Hilarious! This too after charging them a lot of money for the privilege of using their crappy excuse for a product.

If a Company doesn't care about its Customers who give them loads of money, the chances of them caring about you, a lowly developer, are pretty close to zero. You are just someone else to be exploited. They think getting paid for delivering rubbish Software is okay. No moral issues there. Your cheese has been moved.

Use short contracts/probation to your advantage

Contractors are always after long contracts. Permies are always trying to signup for a lifetime at a Company. I think this is all backwards. When contracting I would prefer a weekly contract. Let me tell you why. If the company I'm working at turns out to be a stinking hellhole (and some of them do) the fact that I am only a week-away from getting outa there fills me with hope. Imagine walking into a nightmare workplace and being stuck there for 6 months! Worse - a year! Oh the horror! No amount of money is worth working at some Companies.

One Company I worked at seemed quite normal when I started but a few days into it, it turned out that employees of the Company thought that swearing at each other across the room, daily, was an acceptable way to behave. There were 3 developers always going at it. They were called "The Triangle of Anger". Oh dear! Also it turned out that the management hated the developers and the developers hated the management. With this blood-feud going on I was put on a "mission critical project" by myself and was managed by 5 people - each telling me something different to do! People were leaving the Company left-right-and-centre. There were talks about firing everyone and outsourcing it to another Company. Morale was pretty high as you can imagine! Oh the fun! :)

The same goes for probationary periods for permies. For the first time ever I refused to sign my post-probationary documents. If you find a Company less than optimal to work for during your probation, it's quite likely it's only going to get worse once you sign up fulltime. Here's why: Once you are post-probation, you usually have to give the Company 4 weeks' notice. Try finding another job where they are willing to wait 4 weeks until you finish up at your Company. It's really quite hard. Most jobs need to be filled in under a month. Most of them in 2 weeks. This is just the way Companies seem to work in Brisbane. They only look for developers at the very moment that they need them. Not a (few) month(s) before.

If you are not sure about a Company, start looking for work a month before your probation runs out. That way you usually only need to give a weeks' notice before you head off.

Beware of Amatures

We are all Amatures in one way or another. What I mean by that is that we all have things we don't know. There are always people who know more about something than we do. The features of who I consider to be an "Amature" are given below:

1. Refuses to write tests because "there is no time".

2. Hasn't learned a single new API or language or framework or tool since 2004.

3. Is literally scared to upgrade libraries as it may "break something". "I can't move to Junit4, as the world will implode".

4. Doesn't understand generics. "I like a List that can hold anything. It's more flexible."

5. Prefers XML over annotations because they are more "readable".

6. Thinks that writing Class names into a database table is "all good".

7. Writes 1000 line classes and says "It's good because all the code I need is in one place".

8. Hates TDD because "There is no way you can write tests before you write code".

9. Hates pair programming because it is a "waste of time".

10. Thinks writing hard-to-understand-idiotic-code is macho.

11. Doesn't know the difference between a Unit test and an Integration test.

12. Thinks test isolation is "optional".

13. Doesn't know how to use their IDE.

14. Thinks there is nothing wrong with a 6-hour build.

15. Is afraid of using mocks as "they are too hard to understand".

16. Refuses to use code style such as checkstyle on the source.

17. Refuses to run tests before checking in their code and thereby breaking the build.

18. Thinks that taking 5 days to write 600 lines of mock code to test a Class is fine.

I don't have a problem with people who have the qualities listed above. I do have a problem with people who have the qualities above and who refuse to change. What this means is that it is now 10x harder for you to do a good job as you have constantly fight these "Amatures". They will waste your time and drag you down. Unless you can make a change for the better with these guys there is absolutely no reason to keep working in that same team. Leave while you still can!

The myth of Agile

I'm totally over every single Company I work for claiming to be "Agile". It's just another buzz word to them. "Oh yes! We are Agile! We have x week iterations". What they mean by Agile is:

1. The Software is evaluated at fixed time frame. Usually 2 weeks to a month. (So far so good)

2. The business gets to change their mind every single day. No re-evaluation of the story cards is done.

3. The developers are never consulted for estimation of the story cards or an architect-type is consulted to give estimates for each card (fairly useful since he doesn't implement a single card!)

4. The business expects all their updated changes at the end of the iteration. No excuses! We are "Agile".

5. Testing is optional.

6. There is no acceptance criteria on the story cards - which is good since nothing is accepted!

Most of the time there are no story cards. Just vague requirements that change on a daily basis. When retrospectives are done, all the ideas are just written down and improvements never get implemented. Each retro turns into ground hog day with most people just falling asleep.

Iteration opens follow a similar path with too much work assigned in each iteration as they did the iterations before. The lights are on but nobody's home.

Some have requirements' documents that they've been working on for 6 months! Waterfall anyone? But no. They are "Agile". They know what they are doing. As the projects start to fail they blame the developers and the "Agile" process.

This is such a scam that I am going to ask people real questions about their processes to figure out whether they actually know anything about being "Agile". Don't be fooled by Companies being "Agile". Most aren't. If you are not sure ask them some pointed questions.

Foster good habits

We are all creatures of habit. If you get used to not writing tests then you start to think that not testing your code is fine. If you get used to working in a waterfall methodology, you see nothing wrong with long feedback times and reams of documentation. If get used to tip-toeing around broken builds/tests/deployments then you will think automation is too hard. In everything you do try and do the best job you can.

Some habits to foster:

1. Always write tests for the code you are producing - preferably TDD. If there are no tests - write the tests first then start on your work.

2. If the build is not automated then automate it. It will save the team hours of pain immediately.

3. If there aren't story cards/requirements - do not start work. Write the story cards and acceptance criteria and then estimate it. If you can't do it, get someone with the knowledge to do it. Then start work.

4. If you see quicksand code (code that sucks you in and threatens your life) refactor it! It will not only make the code cleaner but it will increase your understanding of the system. See 1.

5. Don't write an integration test for a piece of code that can be tested thoroughly at the unit level.

6. Run code coverage on any code you write - even if the rest of the team isn't.

7. Run checkstyle or a similar tool to ensure consistent formatting.

8. Write many cohesive small classes. Do this specially if all the other classes are 1000s of lines long.

9. Say "NO" to unrealistic deadlines, features and requests.

10. Where possible try to introduce better processes where you see better alternatives.

11. Check in often - more than a couple of times a day.

Even if the organization you are in is not working in a professional way, that's no excuse for you not to.

As developers we need to have a baseline environment before we start writing code. If this baseline does not exist then our first priority should be to establish this baseline - with approval of course. We should not start work no matter how much of a hurry the Customer is in, if this baseline environment does not exist. This is the bare minimum we need to do a professional job. An example would be having a stable development environment, version control, automating the build, having a CI server, etc. First things first.

Know when to leave

I think we all know whether a Company is good to work at, in under a week. Sometimes you want to give the Company a chance to make improvements. "We are not perfect" they might say. Fair enough. But set a deadline for when some of the improvements should happen by. Most of the time none of the changes proposed are implemented. This might be your signal to leave.

Sometimes it's an external event that signals you to leave. It could be the way the Company treats a certain employee. It could be the way they treat their Customer. It could be the way they treat you. You might notice quite a few people resigning every week (they might know something you don't). It might just be that you have nothing left to learn in the Company and everyday you stay there you lose a little more skill - a little more enthusiasm.

In a Company I worked at a number of years ago, I specifically mentioned that I didn't want to do any form of teamleadership. I wanted to be a developer and that was it. Everyone nodded at the time. Just after my probation had ended, I was thrust into a teamlead position I did not want. There was no choice about it! The eventual result was that I resigned at the end of that project. I didn't want to work for Company where people didn't understand boundaries or English.

At a more recent job, a group of us were coming up with changes to make the broken development processes better. We wanted to ensure the project made it over the line and the customer got a decent product. The outcome was a disciplinary email from the then manager warning each of use to "Stop wasting time" and to "get back to work". He didn't care if the project made or not. All he cared about was how it looked. Us coming up with heaps of changes meant that he looked bad and he had to put a stop to that. The unfortunate thing was that this "shutup and work" attitude was supported by upper management. The last thing I wanted to do was work at a Company where progress was not valued and where voices where drowned out by clarion call of authority. I resigned the next day.

I hope some of the above anecdotes have resonated with you. I am really shocked at how immature the Software industry really is. Imagine telling a builder that you need a building 3 months early. Or imagine changing your mind about whether you want a one or two story house mid way. It's not going to happen is it?

We get these kinds of change requests all the time in Software and we are happy to do it. We need to have better boundaries!

I'll start this experiment with me..... let's see how many jobs I get to keep after that! :)

Hello World Lift

2010-09-29T20:17:00.012+10:00

Recently I've been trying to get into Lift. While there's a lot of information out there there's nothing that really lets a beginner start with the basics.

This post basically gives you the bare minimum configuration and dependencies to get a simple Lift application running. This example just writes some text to the main web page of your application - The ubiquitous "Hello World".

If you find any errors or inaccuracies please let me know as I'm still figuring this stuff out!

The source for this project can be found here.

I'm using SBT for building this project.

The basic structure of this Lift project is as follows:

The SBT properties and SBT project can be found in:

project > build.properties

project > build > LiftProject.scala

The scala source can be found in:

src > main > scala > bootstrap > liftweb (contains a bootstrap class)

src > main > scala > au > com > testlift > snippet (contains snippet code)

Properties are defined in:

src > main > resources > props > default.props (an empty file for now)

The web application structure can be found in:

src > main > webapp (contains html pages that call snippets)

src > main > webapp > WEB-INF

src > main > webapp > templates-hidden (contains templates for your snippets)

With the structure out of the way, lets focus on the LiftProject file for SBT:


import sbt._

class LiftProject(info: ProjectInfo) extends DefaultWebProject(info) {
val liftVersion = "2.1-RC2"

override def libraryDependencies = Set(
"net.liftweb" %% "lift-webkit" % liftVersion % "compile->default",
"net.liftweb" %% "lift-common" % liftVersion % "compile->default",
"net.liftweb" %% "lift-mapper" % liftVersion % "compile->default",
"org.mortbay.jetty" % "jetty" % "6.1.22" % "test->default"
) ++ super.libraryDependencies

}

The above basically defines the minimum dependencies to get this example running. I've left out database drivers and any other dependencies we don't need. We need jetty because we are going to use it to run the example through SBT. I'm using Lift 2.1-RC2 which supports Scala 2.8.

My build.properies file defines basic project attributes:


#Project properties
#Thu Sep 16 20:04:08 EST 2010
project.organization=blah
project.name=HelloWorldLift
sbt.version=0.7.4
project.version=1.0
build.scala.versions=2.8.0
project.initialize=false

As you can see we are building against Scala 2.8. That's it for project setup.

Lift looks for a boostrap class in the bootstrap.liftweb.Boot class.

Boot.scala has the following contents:


package bootstrap.liftweb

import net.liftweb.http.LiftRules
import net.liftweb.sitemap.{SiteMap, Menu}

class Boot {

def boot {
LiftRules.addToPackages("au.com.testlift")
LiftRules.setSiteMap(SiteMap(Menu("Home") / "index"))
}
}

Basically what this code is doing is:

1. Notifying Lift that the classes it needs can be found in the au.com.testlift package. Snippets can be found in au.com.testlift.snippet package.

2. Setting up a Sitemap or Menu with a single entry named "Home" which maps to /index url. You need to setup a Menu entry on the SiteMap for each page you wish to expose through Lift.

That's it for boot setup.

We create a HelloWorld class in the au.com.testlift.snippet package with the following contents:


package au.com.testlift.snippet

class HelloWorld {
def howdy = <span>World!! The current date is: {new java.util.Date}</span>
}

As you can see this snippet is pretty straightforward. The howdy method simply returns a scala.xml.NodeSeq when called.

The main webpage that drives this functionality is the index.html page which can be found under src > main > webapp. Its contents is as follows:


<lift:surround with="default" at="content">
<h1>Hello World Snippet</h1>
Hello <lift:HelloWorld.howdy />
</lift:surround>

Basically what the above block says is to get the value of the howdy method on the au.com.testlit.snippet.HelloWorld class and replace the <lift:HelloWorld.howdy> tag with what it returns. The <life:surround> defines that the <lift:HelloWorld.howdy> tag should be embedded (or surrounded with) the contents of the default.html file at a bind position named "content". The default.html file can be found under src > main > webapp > templates-hidden.

The contents of the default.html file are as follows:


<html xmlns="http://www.w3.org/1999/xhtml" xmlns:lift='http://liftweb.net'>
<head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    <meta name="description" content="" />
    <meta name="keywords" content="" />
    <title>Hello World</title>
</head>
<body>
    <lift:bind name="content" />
    <lift:Menu.builder />    
</body>
</html>

And that's all the main components to get this example running.

Issue the following commands to SBT:

update

jetty-run

If all goes well you should see something like:


[info] jetty-6.1.22
[info] NO JSP Support for /, did not find org.apache.jasper.servlet.JspServlet
[info] Started SelectChannelConnector@0.0.0.0:8080

After all the dependencies have been downloaded and the project compiled, jetty should launch on port 8080. You can verify that everything works by hitting http://localhost:8080/index or http://localhost:8080/

The way I think this works is as follows:

1. The user issues the /index call to the application. This maps to the src > main > webapp > index.html file.

2. When index.html is launched it invokes HelloWorld.howdy to get the contents of its inner <lift:HelloWorld.howdy> tag.

3. It then embeds that result in the src > main > webapp > templates-hidden > default.html template at the "content" bind point. It further adds the single Menu entry "Home" at the <lift:Menu.builder> tag

4. The fully resolved page is sent back to the user.

Further information on Lift can be found here.

Semigroup

2010-07-20T12:46:00.028+10:00

I recently came across something called a "Semigroup" while browsing scalaz code. I was actually looking for an example of a Monoid, but found that the scalaz implementation used Semigroup in the implementation of Monoids.

What is a Semigroup?

A Semigroup is an abstraction of a binary operation where the operands and the result are of the same type.

A functional definition of a Semigroup in scala could be:

def op[T](t1:T, t2:T) : T

The abstraction has to adhere to 2 rules to be considered a Semigroup.

Semigroup Rules

The result of the binary operation should be of the same type as that of the two operands.
The binary operation should be associative.

Rule 1, defines a "closed set", or a closure - which is an operation on elements of a set, that always yield another element of the same set. An example set would be natural numbers. If the operation to abstract was addition, we would get op(1,2) = 3 -> 1+2 = 3, where both 1,2 and 3 are all members of the same set (natural numbers).

Rule 2, defines that if we had a sequence of the same operation, the associativity of the operations would be not change the final result. For example taking the operation as multiplication, we would get op(2, op(4, 5)) = op(op(2,4), 5) -> 2*(4*5) = (2*4)*5

The division operation is not a natural number Semigroup, because the result of dividing through 2 natural numbers may be a real number. Eg. 5/2 -> 2.5. This breaks rule 1, since 2.5 is not a member of the natural number set.

The division operation is also not a real number Semigroup because it is not an associative operation and hence breaks rule 2. Given op(op(27.0,3.0), 2.0) != op(27.0, op(3.0,2.0) -> (27.0/3.0)/2.0 != 27.0/(3.0/2.0)

Some Examples

Here's an implementation of the plus operator:


trait Semigroup[T] {
def op(t1:T, t2:T) : T
}

def plus = new Semigroup[Int] { def op(t1:Int, t2:Int) = t1 + t2 }

Scalaz defines a Semigroup as the following trait:


trait Semigroup[S] {
 def append(s1: S, s2: => S): S
}

and some example implementations from scalaz:


trait Semigroups {
def semigroup[S](f: (S, => S) => S) = new Semigroup[S] {
  def append(s1: S, s2: => S) = f(s1, s2)
}
}

implicit def IntSemigroup: Semigroup[Int] = semigroup(_ + _)
implicit def StringSemigroup: Semigroup[String] = semigroup(_ + _)

Why use Semigroups?

When using any Semigroup implementation, we know that the 2 rules apply: closure and associativity. This gives us knowledge on how to use the API correctly.

For example since we know that Semigroups are associative, we don't have to wonder about what will happen if the associativity of a statement changes. We also know by closure that the types returned are within the same domain as the operands.

Semigroups can also be used to implement other concepts such as Monoids and thus having a Semigroup implementation helps you create further functional concepts.

Any feedback is much appreciated.

Functional Concepts

2010-07-20T12:19:00.008+10:00

One of the biggest hurdles I've come across while learning scala, are all the new functional concepts used - most of which I know nothing about! I've also found it rather to hard to find any succinct information on these concepts, except for Haskell code and mathematical equations. While these are great for those who know Haskell and/or are proficient in mathematics it may not be the easiest thing for a simple programmer (such as myself) to understand.

I believe that in order to become a good functional programmer one needs to understand basic functional concepts and how they are implemented.

In the following months I hope to investigate the following concepts:

Semigroup
Functor
Monoid
Monad
Arrows
Groups
Continuations
Isomorphic
Monomorphic
Referential Transparency
Functional Composition
Higher-order Functions
Higher Kinds
Type Classes

Scala's Alternatives to Exceptions

2010-03-02T10:50:00.014+10:00

I recently posed a series of questions about Scala's alternatives to Exception @ the BFPG. The slides can be found here.

Here is some of the feedback I received on the solutions provided:

By Kristian Domagala:

It looks like Sanjiv raised some interesting questions at the end of his slides. As I wasn't at the meeting, I don't know to what extent the questions were answered, but I thought I would chime in with my 2 cents.

I've found the Either type to be useful for error conditions that can be resolved either through code (eg, using a fallback), or by re-directing back to the user to address. Often this means the Left and Right types are mapped to the same type, and the Either type is merged into a single value (ie, Either[A,A] => A). In the examples you present, you're essentially doing that all together at the end with the fold function.

In terms of chaining exceptions, in Scala terms, this can be handled using flatMap function on the right-projection of Either, assuming you use a common type on the left. Sometimes you will need to map the left types to a common type, but I've found it's usually a String or something representing an exception message, and little additional effort is required.

Going to the particular examples in the slides, I note that the PersistentOutcome type is very similar to Either; ie, Either[String, Unit]. In fact, you could remove the need for pattern matching on the type by aliasing it to Either and re-using the functions defined there:

type PersistentOutcome = Either[String, Unit]

Alternatively, you could achieve the same thing using an implicit def, so that the pattern matching is done in one place and whenever you see a PersistentOutcome, you can treat it as an Either[String, Unit]


implicit def poToStringUnit(po:PersistentOutcome):Either[String,Unit] = po match {  
case Failure(x) => Left(x)  
case Success => Right(())  
}

note that you've started to go down the latter path in the reloaded example. The above gives you something you can re-use anywhere.

Once you've got Either[String,Unit], it's only one left-map away from becoming Either[Exception,Unit]:


def stringUnitToExUnit(e:Either[String,Unit]):Either[Exception,Unit] =   
e.left.map(new Exception(_))

Now we're dealing with more consistent types throughout the execution (Either[Exception,_]), and the addSpends function can be reduced to:


def addSpends(date:Sdate, f:(DailySpend) => Unit):Either[Exception, Unit] =
    Either.joinRight(
      (spender < date).right.flatMap(
        ds => { f(ds); spender > ds }
      ).right.map(stringUnitToExUnit)
    )

To see that I'm not cheating, here's my working:


  def addSpends(date:Sdate, f:(DailySpend) => Unit):Either[Exception, Unit] = {
    val eds:Either[Exception,DailySpend] = spender < date
    val epo:Either[Exception,PersistentOutcome] = 
        eds.right.flatMap(ds => {f(ds); spender > ds})
    val esu:Either[Exception,Either[String,Unit]] = epo
    val eeu:Either[Exception,Either[Exception,Unit]] = 
        esu.right.map(stringUnitToExUnit)
    val eu:Either[Exception,Unit] = Either.joinRight(eeu)
    eu
  }

Going to the main function, I notice that you're folding twice on the same type (Either[Exception,Unit]). You can get rid of the first fold, and with a little bit of point-free style come down to:


def main(args: Array[String]) {
  import Function.const  
  addSpends(yesterday, addItems1).right.flatMap(  
  const(addSpends(today, addItems2))).fold(  
  printError, const(printAllSpends))  
}

Once again, the long-hand:


def main(args: Array[String]) {
  val eu1:Either[Exception,Unit] = addSpends(yesterday, addItems1)  
  val eu2:Either[Exception,Unit] =  
  eu1.right.flatMap(_ => addSpends(today, addItems2))  
  val u:Unit = eu2.fold(e => printError(e), _ => printAllSpends)  
  u  
}

I hope this gives some food for thought and I haven't misinterpreted what you are trying to achieve!

Going to your chaining solution:


val spender = new Spender with LedgeredMemoryPersister
type Result = Either[Exception, Unit]

  def main(args: Array[String]) {
    failFast(List(()=> addSpends(yesterday, addItems1),
                  ()=> addSpends(today, addItems2),
                  ()=> addSpends(SomeDay(18, February(), 2010), addItems2),
                  ()=> addSpends(SomeDay(19, February(), 2010), addItems1),
                  ()=> addSpends(SomeDay(20, February(), 2010), addItems1))).
            fold(ex => printError(ex), r => printAllSpends)
  }

  def failFast(funcs:List[Function0[Result]]) : Result = {
    if (funcs.isEmpty) Right({})
    else (funcs.head.apply()).fold(l => Left(l), r => failFast(funcs.tail))
  }

  def addSpends(date:Sdate, f:(DailySpend) => Result) : Result = {
    (spender < date).fold(l => Left(l), ds => f(ds))
  }

I think it is more complicated than it needs to be. Obviously, if you need to support a variable-length list of functions to execute, then you need something similar to what you wrote. Actually, probably what you want is more along the lines of:


  val params = List((yesterday, addItems1), (today, addItems2). ...)
  params.foldLeft(Right(())((r, p) => r.right.flatMap(addSpends(p))

But if you are just using it as a language feature, then there is something already there for you. First I will write out the long-hand version:


addSpends(yesterday, addItems1).right.flatMap(  
    r1 => addSpends(today, addItems2)).right.flatMap(  
    r2 => addSpends(SomeDay(18, February(), 2010), addItems2)).right.flatMap(  
    r3 => addSpends(SomeDay(19, February(), 2010), addItems1)).right.flatMap(  
    r4 => addSpends(SomeDay(20, February(), 2010), addItems1)))).  
        fold(ex => printError(ex), r5 => printAllSpends)  
}

Using Scala's for comprehensions, this is equivalent to:


def main(args: Array[String]) {
   for (r1 <- addSpends(yesterday, addItems1).right;           
        r2 <- addSpends(today, addItems2)).right;           
        r3 <- addSpends(SomeDay(18, February(), 2010), addItems2).right;           
        r4 <- addSpends(SomeDay(19, February(), 2010), addItems1).right;           
        r5 <- addSpends(SomeDay(20, February(), 2010), addItems1).right)       
   yield ()).fold(ex => printError(ex), r => printAllSpends)  
}

With an implicit conversion from Either to RightProjection, using '_' for the ignored success return values, moving the success case into the yield statement, and mapping the Left type to Unit, that comes down to:


def main(args: Array[String]) {
implicit def EtoRP[A,B](e:Either[A,B]) = e.right  
Either.merge(  
  for (_ <- addSpends(yesterday, addItems1);             
       _ <- addSpends(today, addItems2);             
       _ <- addSpends(SomeDay(18, February(), 2010), addItems2);             
       _ <- addSpends(SomeDay(19, February(), 2010), addItems1);             
       _ <- addSpends(SomeDay(20, February(), 2010), addItems1))         
  yield (printAllSpends)).left.map(printError))   
}

The Either[A,A] type I mentioned is what you need to use Either.merge. In the previous case, it is obtained by calling left.map to convert Either[Exception,Unit] to Either[Unit,Unit].

Another thing to note is that the examples I've provided are a way to show how to better use Either; not necessarily the best way to solve your problem. I would strongly argue that you have way too much in the way of side-effects in the original code. By isolating the side-effects from the purely functional (read: referentially transparent) parts of the code, you could potentially end up with a much more elegant and (de)composable solution. Learning a language that forces you to deal with side-effects will greatly help with working out the isolation.

Finally, I haven't run any of the above through a compiler, so don't be surprised if I've left something out/stuffed something up!

Given all the great solutions given by Kristian above I decided to go with the following:


type Result = Either[Exception, Unit]  
def addSpends(date:Sdate, f:(DailySpend) => Result) : Result  
  
  ...  
  
  type AddByDate = Tuple2[Sdate, Function1[DailySpend, Result]]  
  val params = List[AddByDate](  
                    (SomeDay(16, February(), 2010), addItems1),  
                    (SomeDay(17, February(), 2010), addItems2),  
                    (SomeDay(18, February(), 2010), addItems2),  
                    (SomeDay(19, February(), 2010), addItems1),  
                    (SomeDay(20, February(), 2010), addItems1))  
   params.foldLeft(Right():Result)((r, p) => r.right.flatMap(r1 => addSpends(p._1, p._2))).  
           fold(ex => printError(ex), r => printAllSpends)

Can the syntax be made cleaner I wonder? Anyway, it's been a great learning experience! I've got so much to learn! :)

Intellij can't find test classes in a package

2009-12-03T21:40:00.003+10:00

I came across a very annoying problem while using intellij 8.1.3 today. I could run all the tests from the source package until I introduced a compilation error. After fixing the compilation error, I could no long run all the tests from the source package. Intellij kept insisting that "there are no tests in package xyz" .. which of ofcourse there where.

I had a quick look around the intellij configuration files (usually in your home_directory/.IntelliJIdea8x/system directory) and I came across 2 cache directories:

1. caches
2. compiler

Both had cached files of the project I was working on. The cache files are of the format: project_name_unique_number.

I deleted the cached files of my project from each of the above directories and restarted intellij. This fixed the problem of not finding any tests! :)

Companion Objects

2009-12-01T21:51:00.006+10:00

Scala defines singleton objects with the "object" keyword. If a singleton object shares the same name as that of a class and is defined within the same file, the singleton object is called a "companion object" and the class is called a "companion class". Companionship offers full access to each other's private variables/members. This is similar to an inner class in Java, without the need for an enclosing instance of the outer class.

So what can we do with this new found power of companion objects? Companion object can be used to create companion class instances through factory methods. You could for instance have the companion class extend a trait and make all its constructors private. Then using a factory method on the companion object, you could create an instance of the trait but abstract the companion class out of the equation. We could also provide additional constructors for a class outside the class.

Let's take an example. Say we have a trait:

sealed trait Vehicle {
protected val vin:String
}

Say we also have an extension:


class Car(val vin:String,private val model:String) extends Vehicle

The vin is a protected value in the trait Vehicle and as such can only be accessed by subclasses and the model is private.

We can define a companion object of Car like so:


object Car {

def apply(vin:String, model:String) = new Car(vin, model)
def apply(vin:String) = new Car(vin, "Jaguar")
def apply() = new Car("N/A", "Invisble Car")
def print(car:Car) {println("My " + car.model + "'s vin is: " + car.vin) }
}

By using the companion object we can instantiate Car with:


Car() or Car("1234567") or Car("9876543", "Ford")

The companion object has given us extra constructors for the Car object for free....or so it seems. We have also rid ourselves of the "new" key word that you would normally need to create an instance of a class. Case classes are the exception and now Car behaves a little like a case class thanks to the companion object.

In the print method we see that the companion object does access the protected value "vin" (although it does not extend Vehicle) and the private value "model". Thus we can define methods that need to access the private state of the companion class within the companion object.

One Caveat to keep in mind is that the companions are explicitly linked by name and name alone. Attempting the following will fail although it may "feel" right:

def print2(vehicle:Vehicle) {println("My vehicle's vin is: " + vehicle.vin) }

We get the following compilation error:

error vin cannot be accessed from blog.this.Vehicle

The reason for this failure is that we are trying to access a value from the Vehicle trait and not the Car class. The companion object Car in this case only has access to the state of the companion class Car.

Here's the full example:


package blog

import Car._

object Companionship {

def main(args: Array[String]) {
print(Car())
print(Car("1234567"))
print(Car("9876543", "Ford"))
}
}

sealed trait Vehicle {
protected val vin:String
}

class Car(val vin:String,private val model:String) extends Vehicle

object Car {

def apply(vin:String, model:String) = new Car(vin, model)
def apply(vin:String) = new Car(vin, "Jaguar")
def apply() = new Car("N/A", "Invisble Car")
def print(car:Car) {println("My " + car.model + "'s vin is: " + car.vin) }
//def print2(vehicle:Vehicle) {println("My vehicle's vin is: " + vehicle.vin) }
}

Pop goes the VPN

2009-11-07T18:42:00.004+10:00

Recently my vpn stopped working for no apparent reason. I could connect to the vpn using vpnc, but from there I couldn't ping any of the machines on the network. I had not changed any settings so it was quite puzzling. Friends' using Windows clients were able to connect with the same vpn parameters without any problems. It looked like a dns lookup problem.

Running: cat /etc/resolv.conf confirmed that the vpn dns was not being used.

After googling around a bit I came across this site which gave me a clue on how to configure my dns look ups. I just had to add the following line to my vpnc config file:

NAT Traversal Mode cisco-udp

Now when I ran vpnc, and ran cat /etc/resolv.conf, it confirmed that my vpn dns was used! :)

The complete vpnc config file looks like this:


IPSec gateway xxx.xx.xxx.xxx
IPSec ID your_id
IPSec secret your_secret
IKE Authmode psk
NAT Traversal Mode cisco-udp

Project Euler Problem 1

2009-10-15T19:37:00.003+10:00

Tony mentioned Project Euler more than a few times back in the day when we used to work here. I completely forgot about Project Euler until recently when I restarted learning scala. I thought it would be a good way to further my learning of scala by solving (or trying to solve) some of the Euler problems. Below is my attempt at solving Problem 1.

The Problem:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

This was my first solution [Sol1]:


def getTotal(upper:Int) : Int = multiplesBelow(upper - 1)

 def multiplesBelow(start:Int) : Int = {
   if (start <= 0) return 0     
   if (isMultiple(start)) start + multiplesBelow(start-1) else multiplesBelow(start - 1)   
 } 

def isMultiple(number:Int) : Boolean = (number != 0) && ((number % 3 == 0) || (number % 5 == 0))

Although this solution will give you the expected answer with the following:


 getTotal(1000)

Sol1 is quite clumsy. After a quite scout around the net I found a ruby solution that used ranges and since scala also has ranges I came up with the following [Sol2]:


def getTotal2(upper:Int) : Int = (1 until upper).foldLeft(0)(((a,b) => if (b % 3 == 0 || b % 5 == 0) a+b else a))

I like Sol2 mainly because it is succinct and "simple". I also came up with a solution using map and fold [Sol3]:


def getTotal3(upper:Int) : Int = (1 until upper).map(a => if (a % 3 == 0 || a % 5 == 0) a else 0).foldLeft(0)(_ + _)

Sol3 has an extra step of mapping the function across the values and then folding it.
And there you have the solution to problem 1. I'm sure there are much neater solutions to problem than those above. Please feel free to comment if you have a better solution and/or comments.

The path less followed

2009-09-29T19:46:00.002+10:00

A couple of months ago, I started my scala journey in earnest. You have probably heard of the many benefits of using scala, if not have a look here. I'd like to give you some pointers on how to get started in scala and send you along your interesting journey of discovery.

Your central source of scala is here. You can download the latest version of scala from here. On linux simply download the .tgz, extract it and add the bin directory to your path.

You can verify your installation by invoking the following from a command prompt:


scalac -version

which will output something similar to:


Scala compiler version 2.7.5.final -- Copyright 2002-2009, LAMP/EPFL

To launch the scala interpreter invoke the following:


scala

This will give you a prompt like the following:


Welcome to Scala version 2.7.5.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_14).Type in expressions to have them evaluated. Type :help for more information.

scala>

Greeting the world as per usual can be done as follows:


println("Hello World")

This will print out the String "Hello World" just beneath the println command. As with java, (System.)println prints out a line of text to the standard out.

We can define a simple method as follows:


def greeter(name : String) = println("Hello " +  name + "!")

greeter: (String)Unit

The above means that greeter is the name of the method, which takes a String and returns Unit (or void in java).

It can be invoked as expected:


greeter("Dolly")

Which would give:


Hello Dolly!

You can write any method you like in the interpreter and execute it.

This is good for small programs but not so great for larger ones.

Let's create our first scala class.

First create a folder called blog, which is essentially our package. Now create a file called SimpleGreeter.scala within the blog package with the following contents:


package blog

object SimpleGreeter {

def main(args : Array[String]) {
 if (args.length == 0) println("Usage: SimpleGreeter your_name")
 else  println("Hello " + args.mkString(" ")  + "!")
}
}

This is a simple "main" method with a snippet of code that either displays a greeting based on the arguments supplied or if no arguments are supplied shows the usage.

It's very similar to java's main method definition:


def main(args : Array[String])

public static void main(String[] args)

Go to your source directory and compile the scala class:


scalac blog/SimpleGreeter.scala

If you have a look under your blog package you should see the following classes:


SimpleGreeter.class
SimpleGreeter$.class

We can run the SimpleGreeter with:


scala blog.SimpleGreeter my very long name

We then get the following:


Hello my very long name!

If you call the greeter with no parameters:


scala blog.SimpleGreeter

We get:


Usage: SimpleGreeter your_name

An interesting thing to note is that since scala runs on the VM, we should be able to do this:


java blog.SimpleGreeter my very long name

If we run this we get the following error:


Exception in thread "main" java.lang.NoClassDefFoundError: scala/ScalaObject
 at java.lang.ClassLoader.defineClass1(Native Method)
 at java.lang.ClassLoader.defineClass(ClassLoader.java:621)
 at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124)
 at java.net.URLClassLoader.defineClass(URLClassLoader.java:260)
 at java.net.URLClassLoader.access$000(URLClassLoader.java:56)
 at java.net.URLClassLoader$1.run(URLClassLoader.java:195)
 at java.security.AccessController.doPrivileged(Native Method)
 at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
 at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
 at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
 at blog.SimpleGreeter.main(SimpleGreeter.scala)
Caused by: java.lang.ClassNotFoundException: scala.ScalaObject
 at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
 at java.security.AccessController.doPrivileged(Native Method)
 at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
 at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
 at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
 ... 13 more

What we need to do is include the scala-library.jar library that came with the scala installation into the classpath to make it work. The library is found in the lib directory of the scala installation.

Trying this again:


java -cp .:your_scala_lib_location/scala-library.jar blog.SimpleGreeter my very long name

We get:


Hello my very long name!

This is awesome, because once you compile your scala sources into classes, they are essentially java classes! :) Oh! How sweet it is! :)

I'll leave this introduction there for the moment. Some good resources for further study are:

Programming in Scala by Martin Odersky et al
The Scala website
Some tutorials can be found here and here.
The helpful folks on the scala channel @ irc.freenode.net

NFS Users

2009-08-25T20:51:00.003+10:00

I recently needed to share the same directory between Samba and NFS. The main problem was that Samba accounts were mapped to users and NFS was not. NFS accounts can also be mapped to users by adding the following to /etc/exports


path_to_share   computer_name(rw,all_squash,anonuid=xxx,anongid=yyy)

anonuid is the user id to map to and anongid is the group id to map to when a client from the computer_name connects to the share.

You can find out the user id and group id of a user with


id user_name

Use the value of uid and gid to be anonuid and anongid respectively.

Now when a user from computer_name connects to the share, he connects as user uid and of group gid.

Linux File System Info

2009-08-25T20:20:00.006+10:00

A quick way to find the file system of a particular block device is to use


sudo vol_id device

Eg.


sudo vol_id /dev/sda1

Which would produce something like the following:


ID_FS_USAGE=filesystem
ID_FS_TYPE=ext3
ID_FS_VERSION=1.0
ID_FS_UUID=......
ID_FS_UUID_ENC=...
ID_FS_LABEL=
ID_FS_LABEL_ENC=

You can also use vol_id to generate a uuid for a device


sudo vol_id --uuid device

Eg.


sudo vol_id --uuid /dev/sda1

If you have parted installed


sudo apt-get install parted

you could also do a


sudo parted -l

to find out the file system of all block devices.

Subversion Update Broken in 1.5

2009-08-25T20:10:00.006+10:00

Of recent I have noticed that the good old


svn up dir_name

does not seem to work as it used to. I have had heaps of missing files which were quite visible in the repository on closer examination! After having a dig around the man pages, I came up with the following


svn up -r HEAD --depth infinity dir_name

which achieves what I want. Quite strange. A quick peek at the documentation for Subversion 1.5 states that --depth infinity is default for sparse checkouts. I don't know what changed. Have a go at the code above if you've come across similar problems.

Running Webstart on Linux

2009-08-04T22:03:00.005+10:00

A few people, (myself included) were confused about how to run web start files, specially through the browser.

When firefox prompts you for running jnlp files simply point it to your java_installation_dir/bin/javaws executable. :) It's that easy! :)

On the command line run:


javaws jnlp_url

eg.

javaws http://java.sun.com/docs/books/tutorialJWS/uiswing/components/ex6//TreeDemo.jnlp

You can test it out here.

Java6 plugginess

2009-08-04T21:39:00.005+10:00

Installing a java plugin for Firefox has eluded me for a while. I had a look @ the usual posts but they seemed quite cumbersome. Imagine my surprise when I installed the firefox java plugin in a few easy steps!

1. Install Java6 SE or JRE from here.
2. Find your firefox installation. Mine was in /usr/lib/firefox-3.0.12

If you want to find out where your installation is, type:


grep 'LIBDIR' /usr/bin/firefox

You should see something like:


LIBDIR=/usr/lib/firefox-3.0.12

The LIBDIR variable has the location of the firefox installation.

3. Find the location of libnpjp2.so in your java installation.

Mine was in jdk_install_dir/jre/lib/amd64/libnpjp2.so

4. Change to the /usr/lib/firefox-3.0.12/plugins directory.


cd /usr/lib/firefox-3.0.12/plugins

5. Create a symlink to your libnpjp2.so file.


ln -s jdk_install_dir/jre/lib/amd64/libnpjp2.so libnpjp2.so

Your plugins directory will now have a symlink named libnpjp2.so

6. Open firefox and type:

about:plugins

You should see something like the following:


Java(TM) Plug-in 1.6.0_14

 File name: libnpjp2.so
 The next generation Java plug-in for Mozilla browsers.

You can further test your java installation at the following sites:

Java Tester
Java Verification
Dancing Duke

That's it! :)

References: 1 and 2.

Common NFS Error

2009-07-28T22:01:00.010+10:00

Recently while trying to connect to an NFS share I got a familiar error message:


mount: wrong fs type, bad option, bad superblock on Machine:/path,
     missing codepage or helper program, or other error
     (for several filesystems (e.g. nfs, cifs) you might
     need a /sbin/mount.helper program)
     In some cases useful info is found in syslog - try
     dmesg | tail  or so

I checked the usual configuration files to verify that I had the necessary permissions:


/etc/exports <- client should be allowed here with necessary access rights (r,w,rw etc) 

/etc/hosts.allow 

/etc/hosts.deny <- client should not be listed here.

All the configuration files were valid. The solution to the problem was to install nfs-common:


sudo apt-get install nfs-common

The nfs share can be mounted with:


sudo mount server_name:/path/to/remote/share local_mount_dir

eg.


sudo mount Harry_Hardcore:/home/harry/share  /home/user/share

Enjoy! :)

Apple Silver Keyboard on Ubuntu 9.0.4

2009-07-28T21:45:00.005+10:00

This is becoming a habit. Whenever a new version of Ubuntu comes out, the function keys on my apple keyboard stop working. Not only that, but, the fixes used previously to get them working, don't work any more! Arrrg! The bug still stands.

After a little digging around I came across this article which provided the simple solution. Have a look at your /sys/module/hid_apple/parameters/fnmode file:


cat  /sys/module/hid_apple/parameters/fnmode

Chances are that its value is 1. We need to set this to 2.

We can do this by editing the /etc/rc.local file


sudo vim /etc/rc.local

Add the following lines before the exit 0:


#Added to enable the apple function keys by default.
echo 2 >  /sys/module/hid_apple/parameters/fnmode

save, exit and reboot your system.

Before you give the function keys a go, have another look at the /sys/module/hid_apple/parameters/fnmode file. It should have a value of 2.

After this I discovered that function keys F13-F19 did not work! Sigh. I created ~/.Xmodmap file with the following entries


keycode 191 = Insert
keycode 192 = Print Sys_Req
keycode 193 = Scroll_Lock
keycode 194 = Pause Break
keycode 195 = First_Virtual_Screen
keycode 196 = Next_Virtual_Screen
keycode 197 = Last_Virtual_Screen

clear Shift
clear Lock
clear Control
clear Mod1
clear Mod2
clear Mod3
clear Mod4
clear Mod5
add Shift = Shift_L Shift_R
add Lock = Caps_Lock
add Control = Control_L Control_R
add Mod1 = 0 Alt_L 0x007D
add Mod2 = Num_Lock
add Mod4 = Super_L Super_R
add Mod5 = Mode_switch ISO_Level3_Shift ISO_Level3_Shift ISO_Level3_Shift

keycode 0x7D = equal

This file will be referenced the next time you log in and all should be sweet in the world! :)

And that it should be it.... until the next Ubuntu release!

Also have a look here for alternative solutions.

VPNC with Firestarter

2009-06-25T14:45:00.005+10:00

I had been using vpnc to connect to work for a while now. I was using Ubuntu 8.0.4 and recently upgraded to 8.10. Suddenly my vpnc would not work. I couldn't ping any of the target computers without getting this error:

sendmsg: Operation not permitted

After googling around I found the answer here and here.

Basically what you need to do is:

1. Make the /etc/firestarter/user-pre file editable with chmod 600 or equivalent.
2. Edit the user-pre file as sudo and add the following replacing xxx.xxx.xx.xxx with the ip of your gateway:

iptables -A INPUT -j ACCEPT -s xxx.xxx.xx.xxx -p esp
iptables -A INPUT -j ACCEPT -s xxx.xxx.xx.xxx -p udp -m multiport --sports isakmp,10000
iptables -A INPUT -j ACCEPT -i tun+
iptables -A OUTPUT -j ACCEPT -d xxx.xxx.xx.xxx -p esp
iptables -A OUTPUT -j ACCEPT -d xxx.xxx.xx.xxx -p udp -m multiport --dports isakmp,10000
iptables -A OUTPUT -j ACCEPT -o tun+

3. Save and exit
4. Restart firestarter with sudo ./etc/init.d/firestarter restart.

That should make it all work again.

Pondskum Lives!

2009-06-12T09:59:00.004+10:00

After recently having moved to Bigpond (no thanks to IINET not getting their sh*t together) I wanted to install a linux widget that displayed my current Internet usage. It's easy enough to log into Bigpond but it's cumbersome and involves multiple clicks when all you want to know is your usage.

With Pondskum, I've created a small opensource Java API that logs into your Bigpond account and screen-scrapes (yukk!) data and gives it back to you in a bean. If only Bigpond had a webservice that provided usage information!

I've created 2 guis from the API. One command-line which gives you basic usage information like totals etc and a Swing version that gives you a day-by-day usage table for the current billing month.

This will work until the Bigpond site is redesigned. Have a look if you need an easy way to find out your Internet usage data.

Deploying Maven Artifacts to Googlecode

2009-04-29T10:41:00.014+10:00

Recently I need to deploy a snapshot of one of my opensource projects, into a Maven repository so it could be used by another project. Having a quick look around it seemed that I needed to setup a Maven repository such as Archiva or deploy to a site such as java.net. Neither prospect appealed to me very much.

I had a look at Tom's instinct project and noticed that he was using googlecode to host his artifacts. Now that's more like it! I came across this article that Tom had written on how to export artifacts from Ant into subversion. I didn't fancy using Ant as I wanted to go a purely maven route.

Subsequently I came across this excellent blurb on how to deploy artifacts to a WebDAv server. The author goes on to say that "The trick to this one is to realize that when you share a Subversion repository over HTTP(S), it is actually implemented as a superset of WebDAV". Who knew? That basically means you can use your subversion repository on googlecode as a WebDAv repository.

Cool. I implemented his proposed solution and it all worked with minimal fussing around.

So here are the steps I used to get this working:

1. Update your project pom.xml with the following:


<distributionManagement>
      <repository>
          <id>your-reposiotory-id</id>
          <name>your-reposiotory-name</name>
          <url>dav:https://your-googlecode-project/svn/maven/repository</url>
      </repository>
      <snapshotRepository>
              <id>your-snapshot-repository-id</id>
              <url>dav:https://your-googlecode-project/svn/maven/repository-snapshot</url>
              <uniqueVersion>false</uniqueVersion>
      </snapshotRepository>
</distributionManagement>

  <build>
      <extensions>
              <extension>
                      <groupId>org.apache.maven.wagon</groupId>
                      <artifactId>wagon-webdav</artifactId>
                      <version>1.0-beta-2</version>
              </extension>
      </extensions>

2. Update your settings.xml with the following:


<servers>
      <server>
          <id>your-repository-id</id>
          <username>your-googlecode-username</username>
          <password>your-googlecode-password</password>
          <filePermissions>775</filePermissions>
          <directoryPermissions>775</directoryPermissions>
      </server>
  </servers>
</settings>

The repository id from the pom and the server id from the settings.xml link up a repository with it's server properties. The wagon extension in the pom is needed to do the actual upload.

Now to upload your artifact to your maven repository do a:


mvn clean install deploy:deploy

That's about it if it all goes well. If you get an 401 http error or the like check the file and directory permissions under the server tag in your settings.xml.

For a client to access your freshly created maven repository and artifacts, they need to add the following to an active profile in their settings.xml file:



   <profiles>
       <profile>
           <id>active-profile-id</id>
           <repositories>
               <repository>
                   <id>snapshot-repository-id</id>
                   <url>http://your-googlecode-project/svn/maven/repository-snapshot</url>
               </repository>
               <repository>
                   <id>release-repository-id</id>
                   <url>http://your-googlecode-project/svn/maven/repository</url>
               </repository>
           </repositories>
       </profile>
   </profiles>

That should all work and now you can use your googlecode subversion as a maven repository! :)

No SSH - No No Machine

2009-04-28T21:10:00.007+10:00

I've been using No Machine to remote into machines for quite a while now and all I can say is that I'll never go back to VNC.

I recently completely reinstalled my fileserver with Ubuntu 8.10 and installed the no machine server in the recommended way. I fired up the client and got a "connection refused on port 22". What thaa?

It had been so long since I did a fresh installation of Ubuntu that I'd forgotten that Ubuntu ships with a SSH client but not the server. I found some useful info here. To get your system upto speed all you need to do is:

sudo apt-get install openssh-server openssh-client

You can test it with:

ssh your_user@localhost

Now your system can frolic in its No Machine goodness! :)

Syntax Highlighting Blogger Code

2009-01-07T07:58:00.010+10:00

I finally decided to get some decent syntax highlighting going on blog posts. I hunted around and decided to use the rather cool SyntaxHighlighter. I did run into a few problems though. I've document the steps I've used to get it working, below:

1. Download the latest version of SyntaxHighlighter
2. Unrar the contents into a temporary directory.
3. Host the exploded files on a web server somwhere or in subversion. (which has its own challenges. See below)
4. Edit your blogger layout (Layout -> Edit HTML)
5. Add the following lines just above the end </html> tag, changing http://pinthura.googlecode.com/svn/blogs to match your own path:

The above adds support for the following:

1. C#
2. Java
3. XML
4. CSS
5. Javascript
6. SQL

To add additional language support add the appropriate brush from the http://your_path_/dp.SyntaxHighlighter/Scripts/ directory.

6. Add the following just before the </body> tag:

7. To use highlight code use:

<pre name="code" class="java" >
//your java code here
</pre>

or

<textarea name="code" class="java" >
//your java code here
</textarea>

If you are using a language other than java then check its alias here.

Gotha's with SVN and CSS and HTML files

One problem that had me stumped was that the CSS files could not be read from SVN although they were actually in SVN. The problem stems from using SVN as a HTML source directly and having the correct MIME types. CSS and HTML files by default are returned from http-accessed SVN as "text/plain" which is incorrect. For CSS files we need text/css and for html we need text/html. To achieve this do the following:

Update your ~/.subversion/config file:
1. Uncomment the line enable-auto-props = yes
2. Add the following lines:
*.html = svn:mime-type=text/html
*.css = svn:mime-type=text/css

Now if you import your files into SVN it will get returned with the correct mime types when access via the web.

References

1. SyntaxHighlighter
2. Blog without an Important Name

A Stab @ Reusing Test Code

2009-01-05T19:07:00.014+10:00

I've been looking a way to reuse test code for a while now. Who hasn't written some test code only to have to repeat it in another test class. This is specially the case when you use BDD and have separate test classes for each context.

Refactoring tests does help but it doesn't seem to be the right solution. I've been experimenting with using Test Behaviour Handlers (TBH) to encapsulate the process of expecting, running and verifying code. It seems work quite well.
The term TestBehaviourHandler, is one I've come up with, with my limited imagination! If there is another name for this "pattern" please let me know.

What are the responsibilities of a TestBehaviourHandler?

1. Encapulating all mocking (expectations, assertions, replaying, verifying etc)

2. Ecapulating the method(s) under test. No data is returned. State is modified when methods return values. Assertions verify the returned values.

3. (Optional) Since this models the Builder pattern, return the instance of the TBH from each method.

An Example

The Pinthura project has a class called RandomDataCreatorImpl to generate random test data. We'll focus on the methods that generate random numeric data. Here's a snippet from the class:


public final class RandomDataCreatorImpl implements RandomDataCreator {

private final MathBoundary mathBoundary;

public RandomDataCreatorImpl(final MathBoundary mathBoundary) {
this.mathBoundary = mathBoundary;
}

public int createNumber(final int value) {
return (int) (mathBoundary.random() * value);
}

...
}

Now we could write tests for this method of the form:


import com.googlecode.pinthura.boundary.java.lang.MathBoundary;
import com.googlecode.pinthura.util.builder.RandomDataCreatorBuilder;
import org.easymock.EasyMock;
import org.easymock.IMocksControl;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.Assert.assertThat;
import org.junit.Before;
import org.junit.Test;

public final class ARandomDataCreatorCreatingNumbersUnderTest {

private final IMocksControl mockControl;
private MathBoundary mockMathBoundary;
private RandomDataCreator creator;

public ARandomDataCreatorCreatingNumbersUnderTest() {
mockControl = EasyMock.createControl();
}

@Before
public void setup() {
mockMathBoundary = mockControl.createMock(MathBoundary.class);
creator = new RandomDataCreatorBuilder().withMathBoundary(mockMathBoundary).build();
}

@Test
public void shouldReturnZero() {
expectNumber(0.001, 255, 0);
}

@Test
public void shouldReturnAPositiveNumber() {
expectNumber(0.98, 1000, 980);
}

@Test
public void shouldReturnANegativeNumber() {
expectNumber(0.5, -500, -250);
}

@Test
public void shouldNeverReturnTheSuppliedValue() {
expectNumber(0.9999, 50, 49);
}

private void expectNumber(final double randomValue, final int value, final int expectedVal) {
EasyMock.expect(mockMathBoundary.random()).andReturn(randomValue);
mockControl.replay();

int number = creator.createNumber(value);
assertThat(number, equalTo(expectedVal));

mockControl.verify();
}
}

Suppose we now add a second method that generates random numbers between a range of supplied numbers:


public int createNumber(final int min, final int upperBoundary) {
    int range = upperBoundary - min;
    double randomValue = mathBoundary.random() * range;

    if (min < 0) {
        return (int) mathBoundary.floor(min + randomValue);
    }

    return (int) (min + randomValue);
}

A test case for this method might look like:


import com.googlecode.pinthura.boundary.java.lang.MathBoundary;
import com.googlecode.pinthura.util.builder.RandomDataCreatorBuilder;
import org.easymock.EasyMock;
import org.easymock.IMocksControl;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.Assert.assertThat;
import org.junit.Before;
import org.junit.Test;

public final class ARandomDataCreatorCreatingBoundedNumbersUnderTest {

private final IMocksControl mockControl;
private MathBoundary mockMathBoundary;
private RandomDataCreator creator;

public ARandomDataCreatorCreatingBoundedNumbersUnderTest() {
  mockControl = EasyMock.createControl();
}

@Before
public void setup() {
  mockMathBoundary = mockControl.createMock(MathBoundary.class);
  creator = new RandomDataCreatorBuilder().withMathBoundary(mockMathBoundary).build();
}

@Test
public void shouldReturnABoundedNumber() {
  expectBoundedNumber(0.5, 10, 20, 15);
}

@Test
public void shouldReturnTheMinValue() {
  expectBoundedNumber(0.0001, 300, 555, 300);
}

@Test
public void shouldNotReturnTheUpperBoundary() {
  expectBoundedNumber(0.9999, 50, 100, 99);
}

private void expectBoundedNumber(final double randomVal, final int minVal, final int upperBoundary, final int expectedVal) {
  EasyMock.expect(mockMathBoundary.random()).andReturn(randomVal);
  mockControl.replay();

  int number = creator.createNumber(minVal, upperBoundary);
  assertThat(number, equalTo(expectedVal));

  mockControl.verify();
}

Now this test is almost identical to the previous test.

We could refactor the tests into one test class. This would become messy rather quickly though with the number of methods increasing. Also there is another test case that tests for negative number ranges. This is to be added to a separate test class.

Using the TBH for the above methods gives us:


import com.googlecode.pinthura.annotation.SuppressionReason;
import org.junit.Before;
import org.junit.Test;

public final class ARandomDataCreatorCreatingNumbersUnderTest {

@SuppressWarnings("InstanceVariableOfConcreteClass")
@SuppressionReason(SuppressionReason.Reason.TEST_BEHAVIOUR_HANDLER)
private ARandomDataCreatorCreatingNumbersTBH handler;

@Before
public void setup() {
    handler = new ARandomDataCreatorCreatingNumbersTBH();
}

@Test
public void shouldReturnZero() {
    expectNumber(0.001, 255, 0);
}

@Test
public void shouldReturnAPositiveNumber() {
    expectNumber(0.98, 1000, 980);
}

@Test
public void shouldReturnANegativeNumber() {
    expectNumber(0.5, -500, -250);
}

@Test
public void shouldNeverReturnTheSuppliedValue() {
    expectNumber(0.9999, 50, 49);
}

private void expectNumber(final double randomValue, final int value, final int expectedVal) {
    handler.expectRandomValue(randomValue).replay();
    handler.createNumber(value).assertNumbersAreEqual(expectedVal).verify();
}
}

and


import com.googlecode.pinthura.annotation.SuppressionReason;
import org.junit.Before;
import org.junit.Test;


public final class ARandomDataCreatorCreatingBoundedNumbersUnderTest {

@SuppressWarnings("InstanceVariableOfConcreteClass")
@SuppressionReason(SuppressionReason.Reason.TEST_BEHAVIOUR_HANDLER)
private ARandomDataCreatorCreatingNumbersTBH handler;

@Before
public void setup() {
    handler = new ARandomDataCreatorCreatingNumbersTBH();
}

@Test
public void shouldReturnABoundedNumber() {
    expectBoundedNumber(0.5, 10, 20, 15);
}

@Test
public void shouldReturnTheMinValue() {
    expectBoundedNumber(0.0001, 300, 555, 300);
}

@Test
public void shouldNotReturnTheUpperBoundary() {
    expectBoundedNumber(0.9999, 50, 100, 99);
}

private void expectBoundedNumber(final double randomVal, final int minVal, final int upperBoundary, final int expectedVal) {
    handler.expectRandomValue(randomVal).replay();
    handler.createNumber(minVal, upperBoundary).assertNumbersAreEqual(expectedVal).verify();
}
}

The TestBehaviourHandler looks like this:


import com.googlecode.pinthura.annotation.SuppressionReason;
import com.googlecode.pinthura.boundary.java.lang.MathBoundary;
import com.googlecode.pinthura.util.builder.RandomDataCreatorBuilder;
import org.easymock.EasyMock;
import org.easymock.IMocksControl;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.Assert.assertThat;

@SuppressWarnings({"MethodReturnOfConcreteClass"})
@SuppressionReason(SuppressionReason.Reason.BUILDER_PATTERN)
public final class ARandomDataCreatorCreatingNumbersTBH {

 private final IMocksControl mockControl;
 private MathBoundary mockMathBoundary;
 private RandomDataCreator creator;
 private int number;

 public ARandomDataCreatorCreatingNumbersTBH() {
     mockControl = EasyMock.createControl();
     mockMathBoundary = mockControl.createMock(MathBoundary.class);
     creator = new RandomDataCreatorBuilder().withMathBoundary(mockMathBoundary).build();
 }

 public ARandomDataCreatorCreatingNumbersTBH replay() {
     mockControl.replay();
     return this;
 }

 public ARandomDataCreatorCreatingNumbersTBH createNumber(int value) {
     number = creator.createNumber(value);
     return this;
 }

 public ARandomDataCreatorCreatingNumbersTBH createNumber(int minVal, int upperBoundary) {
     number = creator.createNumber(minVal, upperBoundary);
     return this;
 }

 public ARandomDataCreatorCreatingNumbersTBH expectRandomValue(double randomVal) {
     EasyMock.expect(mockMathBoundary.random()).andReturn(randomVal);
     return this;
 }

 public ARandomDataCreatorCreatingNumbersTBH expectFlooredValue(double intermediateValue, double flooredValue) {
     EasyMock.expect(mockMathBoundary.floor(intermediateValue)).andReturn(flooredValue);
     return this;
 }

 public ARandomDataCreatorCreatingNumbersTBH verify() {
     mockControl.verify();
     return this;
 }

 public ARandomDataCreatorCreatingNumbersTBH assertNumbersAreEqual(int expectedVal) {
     assertThat(number, equalTo(expectedVal));
     return this;
 }
}

Here are the tests for negative number ranges:


import com.googlecode.pinthura.annotation.SuppressionReason;
import org.junit.Before;
import org.junit.Test;

public final class ARandomDataCreatorCreatingBoundedNegativeNumbersUnderTest {

  @SuppressWarnings("InstanceVariableOfConcreteClass")
  @SuppressionReason(SuppressionReason.Reason.TEST_BEHAVIOUR_HANDLER)
  private ARandomDataCreatorCreatingNumbersTBH handler;

  @Before
  public void setup() {
      handler = new ARandomDataCreatorCreatingNumbersTBH();
  }

  @Test
  public void shouldReturnTheMinValue() {
      handler.expectRandomValue(0.001).expectFlooredValue(-9.995, -10).replay();
      handler.createNumber(-10, -5).assertNumbersAreEqual(-10).verify();
  }

  @Test
  public void shouldNotReturnTheUpperBoundary() {
      handler.expectRandomValue(0.999999).expectFlooredValue(-100.0001, -101).replay();
      handler.createNumber(-200, -100).assertNumbersAreEqual(-101).verify();
  }

  @Test
  public void shouldReturnANumberBetweenNegativeAndPositveBounds() {
      handler.expectRandomValue(0.4).expectFlooredValue(-1, -1).replay();
      handler.createNumber(-5, 5).assertNumbersAreEqual(-1).verify();
  }
}

The TestBehaviourHandler has been reused in the above test case as well.

The Disadvantages

1. You have to write yet another class. (The TBH)
2. You have to repeat the mocking code in each TBH.
One improvement that has to be done is to move the mocking code into a common class allowing the user to supply additional test behaviour only. This would allow the user to focus only on the test behaviour and not the mocking/ setup code.

The Advantages

1. Reuse of test code.
2. Test cases are kept smaller.
3. The tests are easier to read and maintain.

I'll keep using this "pattern" and see how it can be improved. Any comments and/or suggestions are welcome.

Sharing a VirtualBox folder with Windows on Ubuntu

2008-12-22T13:14:00.005+10:00

1. Install VirtualBox and the guest additions on Ubuntu.

2. Install a flavour of Windows on the virtual image.

If you are using the open-source version do the following:

1. To find out the the name (and other information) of your vm use:

vboxmanage list vms

You should get a listing of the sort:

Name: WindowsXP
Guest OS: Windows XP
UUID: ...
Config file: /home/sanjiv/.VirtualBox/Machines/WindowsXP/WindowsXP.xml
Memory size: 2000MB
VRAM size: 64MB
Boot menu mode: message and menu
ACPI: on
IOAPIC: off
Time offset: 0 ms
Hardw. virt.ext: off
State: powered off (since 2008-12-22T02:18:59.000000000)
Monitor count: 1
Floppy: empty
Primary master: /home/sanjiv/.VirtualBox/Machines/WindowsXP/Snapshots/{...}.vdi (UUID: ...)
Primary slave: /home/sanjiv/.VirtualBox/Machines/WindowsXP/Snapshots/{...}.vdi (UUID: ...)
DVD: /home/sanjiv/.VirtualBox/VBoxGuestAdditions_1.5.6.iso (UUID: ...)
NIC 1: MAC: ..., Attachment: NAT, Cable connected: on, Trace: off (file: ), Type: Am79C973
NIC 2: disabled
NIC 3: disabled
NIC 4: disabled
UART 1: disabled
UART 2: disabled
Audio: disabled (Driver: Unknown)
Clipboard Mode: Bidirectional
Shared folders:

To find out specific information about a vm use:

vboxmanage showvminfo name_of_vm

2. On linux run:

vboxmanage sharedfolder name_of_vm -name name_of_share -hostpath path_to_shared_linux_folder

Eg.

vboxmanage sharedfolder "WindowsXP" -name "vbshare" -hostpath "/home/sanjiv/vbshare"

3. On the Windows VM, open Devices -> Shared Folders... It should list
your shared folder:

4. Run

net use DRIVE_LETTER_FOR_SHARE \\vboxsvr\name_of_share
Eg.

net use s: \\vboxsvr\vbshare

use the literal vboxsvr as is.

Now when you write to your S: drive from Windows, you can see the changes in the linux folder
you shared and vice versa. In the above example the linux folder is /home/sanjiv/vbshare.

If you are using closed-sourced edition of VirtualBox do the following to share a folder:

1. In the Windows VM, open Devices -> Shared Folders...

2. Click the Add new shared folder button.

3. Select the path to the folder to share and give the shared folder a name.

4. Open a command prompt and type:

net use YOUR_DRIVE_LETTER: \\vboxsvr\NAME_OF_SHARE

eg. net use F: \\vboxsvr\myshare

5. Your share should now be visible within My Computer.

Silver Apple Keyboard on Ubuntu 8.10

2008-12-18T00:26:00.005+10:00

Edit the file /etc/modprobe.d/options and add the line:
options hid pb_fnmode=0

Save the file and execute the following command:
sudo update-initramfs -u

Reboot.

Add the following to your ~/.Xmodmap file. Create the file if there isn't one.

keycode 191 = Insert
keycode 192 = Print Sys_Req
keycode 193 = Scroll_Lock
keycode 194 = Pause Break
keycode 195 = XF86AudioMute
keycode 196 = XF86AudioPrev
keycode 197 = XF86AudioNext

clear Shift
clear Lock
clear Control
clear Mod1
clear Mod2
clear Mod3
clear Mod4
clear Mod5
add Shift = Shift_L Shift_R
add Lock = Caps_Lock
add Control = Control_L Control_R
add Mod1 = 0 Alt_L 0x007D
add Mod2 = Num_Lock
add Mod4 = Super_L Super_R
add Mod5 = Mode_switch ISO_Level3_Shift ISO_Level3_Shift ISO_Level3_Shift

keycode 0x7D = equal

I've removed the command and alt key swapping from the above. If you want the key swap add the following as well:

keycode 37 = Control_L
keycode 133 = Alt_L Meta_L
keycode 64 = Super_L
keycode 108 = Super_R
keycode 134 = ISO_Level3_Shift Multi_key
keycode 105 = Control_R Multi_key

Logout and then back in.

References: Ubuntu community

Enumerations with Null Objects

2008-09-05T16:55:00.009+10:00

What's all this about?

Since Java 1.5 we can simply define elements of a fixed set of values with the enum keyword. When a method accepts an enum, you have to either use a value from the enumeration or null to call that method. Altough I've been designing to interfaces, I, for some reason, never used interfaces when using enums. I've also been trying to avoid using nulls. To get around using them, I added an extra element to the enum to represent a null object. This was not great, since it polluted the enumeration and lead to unnecessary conditional code in some of the methods. In this post I look @ another way of using null objects, via interfaces, where enumerations are accepted.

Show me the problem!

For this example I'm going to take the monetary values of 10, 20 and 50 dollar notes as an enumeration. Say I need to work with these 3 notes for some purpose. I also added an element value for any other value that does not exist (a null value). The resulting enumeration would look something like this:


public enum DollarValueEnum {

NULL(-1), TEN(10), TWENTY(20), FIFTY(50);

private final int numericValue;

DollarValueEnum(final int numericValue) {
 this.numericValue = numericValue;
}

void print() {
 if (!this.name().equals(NULL.toString())) {
     System.out.println("The value of this element is: " + numericValue);
 } else {
     System.out.println("There is no value for this element.");
 }
}
}

Due to the NULL element the print method is a little ugly with the if-else block.

We can run the above through a runner like:


public final class DollarValueRunner {

public static void main(String[] args) {
  print(DollarValueEnum.TEN);
  print(DollarValueEnum.TWENTY);
  print(DollarValueEnum.FIFTY);
  print(DollarValueEnum.NULL);
}

private static void print(final DollarValueEnum dv) {
  dv.print();
}
}

We get the output:


The value of this element is: 10
The value of this element is: 20
The value of this element is: 50
There is no value for this element.

So the above code lets us use the 3 element values (10, 20 and 50) along with another value (NULL) representing any other value that might be used (say when we needed to signify that there was no dollar value for something).

Some of the problems with the above are:

* The enumeration needlessly knows about the NULL element. It should only know about the valid elements (10, 20 and 50).
* Methods that accept the enumeration can't accept anything else (using concrete classes).

* If we need values of the enumeration for processing some data then we need to exclude the NULL element from the values returned.

Eg. If I need to find all the notes less than or equal to 20, then I would have to write something like:


public List< DollarValueEnum> findDollarValuesLessThanOrEqual(final int numericValue) {
        List< DollarValueEnum> reducedList = new ArrayList< DollarValueEnum>();
        for (DollarValueEnum dollarValue : getDollarValuesExcludingNull()) {
            if (dollarValue.getNumericValue() <= numericValue) {
                reducedList.add(dollarValue);
            }
        }

        return reducedList;
}

public List< DollarValueEnum> getDollarValuesExcludingNull() {
        final DollarValueEnum[] dollarValues = DollarValueEnum.values();
        return Arrays.asList(dollarValues).subList(1, dollarValues.length);
}

What other ways can we do this?

We could rewrite the above such that the DollarValueEnum implements an interface and thereby allows us to have a null object implementation of that interface outside the enumeration:


public interface DollarValue {
void print();
}

The enumeration would be updated as so:


public enum DollarValueEnum implements DollarValue {

TEN(10), TWENTY(20), FIFTY(50);

 private final int numericValue;

 DollarValueEnum(final int numericValue) {
     this.numericValue = numericValue;
 }

 public void print() {
     System.out.println("The value of this element is: " + numericValue);
 }
}

A null object could now be implemented:


public final class NullDollarValue implements DollarValue {

public void print() {
 System.out.println("There is no value for this element.");
}
}

We can also dynamically swap between implementations of the DollarValue interface (coding to interfaces):


public final class DollarValueRunner {

public static void main(String[] args) {
 print(DollarValueEnum.TEN);
 print(DollarValueEnum.TWENTY);
 print(DollarValueEnum.FIFTY);
 print(new NullDollarValue());
}

private static void print(DollarValue dv) {
 dv.print();
}
}

The output would be the same as before:


The value of this element is: 10
The value of this element is: 20
The value of this element is: 50
There is no value for this element.

Why go through the extra effort?

* We can see from the above that we can use the DollarValueEnum class or any implementation of the DollarValue interface with the print method. This gives us greater flexibility.
* The enumeration has no concept of a null object. This keeps the enumeration simple.
* It's easier to mock out the interface in interaction tests, rather than using state-based tests for enumerations.

Eg. If a method returned an enumeration then we would have to test that it would return any one of the enumeration values - not just one.


DollarValueEnum findDollar(Criteria criteria) { .. }

If an interface was returned, we could simply use mocks to verify that what was expected was always returned.


DollarValue findDollar(Criteria criteria) { .. }

What are the draw backs?

* We obviously have more classes now to do the same job. (Although we could combine the interface and enumeration and null object into one class and cut down the number classes.)
* It's arguable that it's clearer to have all states within the enum (including a null state) as it makes the code clearer.

nVidia Video Drivers on Hardy

2008-08-01T02:10:00.004+10:00

After my lovely ATI x1950Pro refused to work nicely with Ubuntu 8.0.4, I ran out and bough myself an nVidia 8800GT. The video drivers were surprisingly easy to install and I was up-and-running in less than 30 mins! :)

Here are the steps:

Before you start, download the latest nVidia driver for the 8800GT (or your card). Note where you downloaded it to, as you will need it in the following steps.

1. In a terminal window type:

sudo apt-get install build-essential

2. followed by:

sudo apt-get remove nvidia*

to get rid of any unwanted nVidia drivers. Also check /lib/linux-restricted-modules/`uname -r`/video and make sure there's no nvidia directory in there.

3. Change to terminal mode by using Ctrl+ALT+F1. (F1 to F6 should work)

4. Shutdown any remnant gmd processes with:

sudo /etc/init.d/gdm stop

5. Go to the directory where you downloaded the latest nVidia driver and type:

chmod a+x NVIDIA-Linux-x86_64-173.14.05-pkg2.run

Depending on which release of the driver you downloaded the .run filename may change.

6. Run the driver with:

sudo sh ./NVIDIA-Linux-x86_64-173.14.05-pkg2

7. Answer the questions on screen.

8. If you get an error about not finding a compiled kernel for your driver version, ask the installer to compile one for you.

9. You may get an error of the type "/usr/lib32/libGL.so.173.14.05 can't be found". Ignore this error and continue.

10. Reboot your machine with:

reboot

11. On logging into your machine, open a terminal and run:

sudo nvidia-settings

This will launce nVidia's gui configuration tool for you to make any changes :)

You should have compiz running. Desktop effects should have defaulted to "Extra"

12. Install the 32-bit compatibility libraries (not sure if you really need this, but, it made my installation more stable under compiz) with:

sudo apt-get install ia32-libs

Enjoy! :)

References: [1] [2]

Hardy Apple Crumble

2008-05-20T00:48:00.004+10:00

Update This wiki page on the Ubuntu site addresses this issue in full.

Following the resolution problem with Ubuntu 8.0.4, the next hurdle I had was getting my slim apple keyboard to play nice. Due to driver updates, after logging into Ubuntu the keyboard becomes unusable. I later read this post which reassured me that I wasn't going mad. (or madder than I currently am!)

"pressing "Clear" (numlock key) results in right part of the main keyboard part (keys g-l on the middle row + keys around) to behave as a numeric pad. To set it back, I found after lengthy trial-error, that I have to press F5 (or F6, I'm not sure)."

After banging the F6 key, my keyboard returned to normal. Phew. The only problem now was that the function keys performed as if the previously vestigial Fn was pressed the whole time. So for example if I pressed F1, it would decrease the brightness of my laptop screen! How annoying!

After digging around the I found a this excellent post which helped me turn off the default Fn key behaviour for apple keyboards.

To get your apple keyboard back to how it functioned in Ubuntu 7.10 do the following:

1. Add a file to the /etc/modprobe.d/ directory with the following contents:

options hid pb_fnmode=2

This turns off the default Fn key behaviour of always being on.

2. Add the following to Preferences->Session->Startup Programs section:

xmodmap -e 'keycode 77='

This turns off the mapping for the "Clear" key (keycode 77) on the apple keyboard which is wreaking havoc.

3. Restart your machine and enjoy the normality :)

This is now a bug. Hopefully it will be resolved soon.

Hardy Resolution

2008-05-20T00:10:00.005+10:00

I recently upgraded from Ubuntu 7.10 to 8.0.4 through the automatic update process. I naively assumed "this is linux....it will just work". Yes. I was wrong.

Firstly I was running Ubuntu on my Dell Inspiron 6400 laptop which has a ATl Mobility Radeon X1400 graphics card. I had this all setup on 7.10 to run @ the native 1680x1050 resolution. 8.0.4 had dropped that back to 1440 x 1050. Great. I followed all the same steps I had in 7.10 to get back my previous resolution and it worked (thankfully) once I manually added my 1680x1050 resolution to the /etc/X11/xorg.conf file. The steps are outlined below:

1. Disable composite extensions
The proprietary ATI dirver (fglrx) does not yet support composite.extensions In order to disable composite extensions you have to edit the xorg.conf file:

sudo gedit /etc/X11/xorg.conf

and add these lines at the end of the /etc/X11/xorg.conf file:

Section "Extensions"
   Option "Composite" "0"
EndSection

2. Install the ATI driver
Open a terminal and enter the following in order to install the ATI driver:

sudo apt-get update
sudo apt-get install linux-restricted-modules-$(uname -r)
sudo apt-get install xorg-driver-fglrx
sudo depmod -a

3. Configure the driver
Type in the following to update the xorg.conf file with the new driver:

sudo aticonfig --initial
sudo aticonfig --overlay-type=Xv

4. Completing the installation
Restart the computer with the following:

sudo shutdown -r now

5. Post installation check
Upon restarting the machine you should be able to choose the screen resolution of 1680x1050 under the Preferences -> Screen Resolution setting. If the screen resolution can't be found and the max resolution is still 1440x1050, edit the xorg.cof file and add the 1680x1050 resolution manually:

sudo edit /etc/X11/xorg.conf

Update the Modes section to include the 1680x1050 resolution:

Section "Screen"
   Identifier "Default Screen"
   Device "Generic Video Card"
   Monitor "Generic Monitor"
   DefaultDepth 24
   SubSection "Display"
      Modes "1400x1050" "1680x1050"
   EndSubSection
EndSection

Restart the computer with the following:

sudo shutdown -r now

Check the Preferences -> Screen Resolution setting and change the resolution to 1680x1050.

To verify that the fgl driver has been installed correctly, run the following command to check its output to ensure the fglrx driver is installed properly:

fglrxinfo

The output from the driver should read:

display: :0.0 screen: 0
OpenGL vendor string: ATI Technologies Inc.
OpenGL renderer string: ATI Mobility Radeon X1400
OpenGL version string: 2.1.7412 Release

Enjoy! :)

Google Maps - Blocked

2008-04-23T23:39:00.002+10:00

My wireless router recently stopped working and I was forced to recede to my Billion (BiPAC 7402L) wired router. After reconfiguring the full network, I found out from my flatmate that Google Maps wasn't working. Strange. After verifying this I had a look @ the firewall settings on the router and Port 80 was open for outgoing TCP traffic.

I turned off the firewall and Google maps was up and running, proving that it was indeed a firewall problem. On a whim I added a UDP firewall rule for port 80 for outgoing traffic and this solved the problem! Something about the way Google Maps works requires UDP - not just TCP/IP. All very strange! :)

Spring Annotations Hierarchy

2008-03-07T19:42:00.005+10:00

A while back I got this cryptic error:

"No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here".

I had wired hibernate3.3 with Spring 2.5.2 through annotations on a Spring Web Services project.

I checked the obvious:

1. That I had declared my transaction boundaries using the @Transactional annotation.
2. The Hibernate SessionFactory was being injected as expected.
3. I was using the <tx:annotation-driven /> tag with the default transaction manager.

All were used and created as expected. I was using Spring's <context:component-scan> tag to automatically scan for component (@Component and its derivatives) classes.

I also had two configuration files:

1. (The default) spring-ws-servlet.xml.
2. (A custom) persistence.xml

My <context:component-scan> tag was in the spring-ws-servlet.xml while my <tx:annotation-driven /> tag was in the persistence.xml file. This worked fine if I wired the transactional bean explicitly in the persistence.xml file. After using <context:component-scan > I removed the explicit declaration. Following this I got the stated error message. For some reason when annotations were being used to wire the beans, the <tx:annotation-driven /> tag was not "visible" to the beans loaded through annotations. Once I moved the <tx:annotation-driven /> tag to the spring-ws-servlet.xml config file it all worked and the error went away.


<beans ...>
     ...          
     <context:component-scan ...>
     <tx:annotation-driven />
     ...     
</beans>

It would seem that there is a hierarchy in Spring configuration files. Where those resolved first are visible to those loaded after them and those resolved after are not visible to those resolved before them. I discussed this with a colleague (Dan Everton) who mentioned that Spring has a parent-child relationship when resolving configuration files. "The parent configuration file is like a base class and the child configuration file like a subclass." I assume that the annotation-wired beans are part of the "parent" configuration and are thus visible to all other configurations loaded there after.

I did some hunting around but couldn't find any documentation to support or negate this theory. But using this assumption and moving the <tx:annotation-driven /> tag to the "parent" configuration file made everything work.

If anyone knows how these files are resolved please add a comment.

Gaining through Grids

2008-02-20T00:28:00.006+10:00

Tom's got a blurb on the excellent Grid presentationNick and he gave at the recent QJUG. Some pictures follow:

Nick and Glen conspire

Good questions as always

Interesting punch-lines! :)

Good work guys! :)

Many thanx to the wonderful folks @ VLC for hosting and giving us the opportunity to work on such an interesting project.

Aaaargclipse!

2008-02-19T00:25:00.009+10:00

Oh how I love installing and using wondrous Eclipse. It is a tool of fun and frolic not to mention of much utility.

No. Not really. A while back I was trying to install Eclipse on 64-bit Ubuntu 7.10. Easy enough. I had done it several times before. So this should be a cinch right? Well not exactly. When I ran eclipse after installation I kept getting weird errors such as:

error while loading shared libraries: libgtk-x11-2.0.so.0: cannot open shared object file: No such file or directory

Yes, brilliant! So what does that tell me? Oh so I need libgtk-x11-2.0.so.0. So why don't I have it? What? I do? Ok....?

Or the equally self-explanatory:

Superb! Could I ask for a more meaningful error message? Possibly. Definitely. Maybe. (Isn't that a movie?)

After hours of trying to fix this problem by installing libraries I didn't need, I found out that I had installed the 32-bit version of Eclipse on my 64-bit OS. An error message of the sort "I think you are trying to install a 32-bit version of Eclipse on a 64-bit platform. Are you sure you want to do this?" might have been nice. It would have saved me hours of what I like to call "wasting time with Eclipse".

So why did I install the wrong version of Eclipse? The eclipse website detects the version of the OS you are running and guides you to the appropriate download. So when I went to the site from 64-bit Ubuntu it took me to:

Now if I click on the "linux" link, it takes me to the 32-bit download, which is totally wrong for my platform and leads to hours of fun, installing superfluous libraries! Yay!

But if I click on the "Eclipse Classic 3.3.1.1" link it takes me to the correct 64-bit download:

So why is the eclipse web site so confusing? It's probably the same the reason why eclipse is so hard to use! :)

If you are installing eclipse on Ubuntu 64-bit, make sure you have the
xxxx-gtk-x86_64.tar.gz version as opposed to the xxxx--gtk.tar.gz version.

Enough Eclipse-bashing. Have you tried Intellij btw? ;)

Partial Implementations with Traits

2008-02-05T16:16:00.000+10:00

A trait in Scala is similar to an interface in Java. It's similar in the sense that it defines a contract (through methods signatures) as a Java interface would. It also has the capability of implementing the methods it defines, similar to an abstract class in Java. This is known as "partial implementation" as it implements some but not all of the methods on the trait. Traits can also be used as mixins to given functionality similar to multiple inheritance. In Java we implement interfaces and in Scala we extend traits.

The examples below use the trait's partial implementation similar to that of abstract classes in Java. I know many people hate using abstract classes and inheritance for that matter, due to one reason or another (hard to test, complex, inflexible take your pick - or have a look @ Tom's article The practical problems of inheritance). But everything has a time and a place. We are going to ignore the above (valid) arguments for the moment and see what traits can do for us by providing partial implementations.

So let's see this partial implementation jazz already.

Suppose we had an interface similar to the java.awt.event.MouseListener interface. Most of the time you are only interested in 1 or 2 of the methods on this interface and providing implementations for the other methods is a pain in the rear. The java.awt.event.MouseAdaptor class provides default implementations of all methods on the MouseListener interface, allowing the developer to override only the method(s) of interest. Let's create a similar interface to the MouseListener interface in Java:


public interface JavaMouseEvent {}

public interface JavaMouseListener {
   void mouseClicked(JavaMouseEvent e);
   void mousePressed(JavaMouseEvent e);
   void mouseReleased(JavaMouseEvent e);
   void mouseEntered(JavaMouseEvent e);
   void mouseExited(JavaMouseEvent e);    
}

Now say we are only interested in the mouseClicked event. We create our own adaptor class in the form of a trusty abstract class or a base class:


public abstract class JavaMouseAdaptor implements JavaMouseListener {
   @Override
   public void mouseClicked(JavaMouseEvent e) {}

   @Override
   public void mouseEntered(JavaMouseEvent e) {}

   @Override
   public void mouseExited(JavaMouseEvent e) {}

   @Override
   public void mousePressed(JavaMouseEvent e) {}

   @Override
   public void mouseReleased(JavaMouseEvent e) {}
}

Now we can handle the mouseClicked event as so:


public class JavaEventHandler extends JavaMouseAdaptor {
   @Override
   public void mouseClicked(JavaMouseEvent e) {
       System.out.println("The mouse has been clicked! Call the mouse brigade");
   }
}

In Scala we could do the above with:


trait ScalaMouseEvent

trait ScalaMouseListener {
   def mouseClicked(e: ScalaMouseEvent): Unit = {}
   def mousePressed(e: ScalaMouseEvent): Unit = {}
   def mouseReleased(e: ScalaMouseEvent): Unit = {}
   def mouseEntered(e: ScalaMouseEvent): Unit = {}
   def mouseExited(e: ScalaMouseEvent): Unit = {}
}

final class ScalaEventHandler extends ScalaMouseListener {
   override def mouseClicked(e: ScalaMouseEvent): Unit = {
       println("The mouse has been clicked! Call the mouse brigade")
   }
}

We essentially, have cut out the adaptor class - which we didn't need thanks to partial implementation of traits in Scala. This is also easier to maintain because the implementation is in the same location/File as the definition of the contract.

If we wanted to look beyond default implementations of a trait, we could implement a pattern such as the Template pattern, through a trait with partial implementation. Say we had a process, and every process had a start, step1, step2, step3 and end stages. And further assume that each process has a processName. We could model the process through the template pattern in Java like so:

public interface Process {
   void start();
   void step1();
   void step2();
   void step3();
   void process();
   void end();
   String getProcessName();
}

public abstract class AbstractProcess implements Process {
   public void start() {
       System.out.println("Starting process: " + getProcessName());
   }

   public abstract void step1();
   public abstract void step2();
   public abstract void step3();

   public void process() {
       start();
       step1();
       step2();
       step3();
       end();
   }

   public void end() {
       System.out.println("ending process: " + getProcessName());
   }

   public abstract String getProcessName();
}

public final class ReviewProcess extends AbstractProcess {
   @Override
   public String getProcessName() {
       return "Review Process";
   }

   @Override
   public void step1() {
       System.out.println("processing step1");
   }

   @Override
   public void step2() {
       System.out.println("processing step2");
   }

   @Override
   public void step3() {
       System.out.println("processing step3");
   }
}

We run the code with:


new ReviewProcess().process();

The output we receive is:


Starting process: Review Process
processing step1
processing step2
processing step3
ending process: Review Process

In Scala we could do the same thing through a trait:


trait Process {
   def start:Unit = println("starting process: " + processName)

   def step1:Unit
   def step2:Unit
   def step3:Unit

   def end:Unit = println("ending process: " + processName)           

   def process():Unit = {
       start
       step1
       step2
       step3
       end
   }

   def processName: String
}

final class ReviewProcess extends Process {
   override def step1(): Unit = println("processing step1")
   override def step2(): Unit = println("processing step2")
   override def step3(): Unit = println("processing step3")
   override def processName(): String = "Review Process" 
}

If we run the above code with:


new ReviewProcess().process

The output we receive is:


starting process: Review Process
processing step1
processing step2
processing step3
ending process: Review Process

The template pattern implementation is much more terse in Scala. Just as you could override methods on base class via the subclass in Java, you can override methods implemented on the trait with the override keyword from the extensions of the trait:



final class AutomationProcess extends Process {
   override def step1(): Unit = println("automating step1")
   override def step2(): Unit = println("automating step2")
   override def step3(): Unit = println("automating step3")
   override def processName(): String = "Automation Process"
   override def start = println("Commencing the following process: " + processName)
}

Running the above through

new AutomationProcess().process

yeilds:


Commencing the following process: Automation Process
automating step1
automating step2
automating step3
ending process: Automation Process

If we don't want an implementation to be overridden, we declare the method final, with def final. For example to prevent the start method being overridden, we could use the following on the Process trait:


final def start:Unit = println("starting process: " + processName)

Making the template methods final is a good practice when implemented using inheritance.

So the question is whether implementations on the trait are a good thing. Sure, it's flexible but it goes against some "standard" practices in Java. I find traits useful for instances like the MouseListener example, where I only ever have one use for the extension and where I don't really care about the other implementations. For the template pattern a delegation solution would be easier to use and maintain without partial implementations.

Gmail Vulnerable to Sidejacking

2008-02-03T12:53:00.000+10:00

"Last August, security researcher and CEO of Errata Security Robert Graham demonstrated just how easy it could be access potentially serious user information. His technique (nicknamed sidejacking), intercepts session ID cookies from the WiFi signal and used for a number of purposes, including sending and receiving e-mail. This type of attack takes place after the end-user has securely logged on to a service. Virtually all companies provide a secure login portal, but many do not secure the connection thereafter, which exposes the end-user to potential hacking as described above. During his demonstration at the time, Graham said that Google Mail users could switch to https://mail.google.com and secure their session from such snooping—but he's now backed away from and qualified that statement."

Check out the full article here.

Ubuntu: What's Under the Hood

2008-02-03T10:18:00.000+10:00

I recently stumbled upon the rather useful lshw command. The lshw command provides you with hardware configuration information of your machine. Its man page states:

"lshw is a small tool to extract detailed information on the hardware configuration of the machine. It can report exact memory configuration, firmware version, mainboard configuration, CPU version and speed, cache configuration, bus speed, etc. on DMI-capable x86 or IA-64 systems and on some PowerPC machines (PowerMac G4 is known to work).

It currently supports DMI (x86 and IA-64 only), OpenFirmware device tree (PowerPC only), PCI/AGP, CPUID (x86), IDE/ATA/ATAPI, PCMCIA (only tested on x86), SCSI and USB."

Some sample usages:

For a summary of devices on your system:

sudo lshw -short


H/W path               Device     Class       Description
=========================================================
                               system      Desktop Computer
/0                                bus         K8M800-8237
/0/0                              memory      128KB BIOS
/0/4                              processor   AMD Sempron(tm) Processor 2800+
/0/4/8                            memory      128KB L1 cache
/0/4/9                            memory      256KB L2 cache
/0/18                             memory      1536MB System Memory
/0/18/0                           memory      1GB DIMM 400 MHz (2.5 ns)
/0/18/1                           memory      512MB DIMM 400 MHz (2.5 ns)
/0/e4000000                       bridge      K8M800 Host Bridge
/0/e4000000/1                     bridge      VT8237 PCI bridge [K8T800/K8T890 South]
/0/e4000000/1/0                   display     S3 Unichrome Pro VGA Adapter
/0/e4000000/9          scsi0      storage     VT6421 IDE RAID Controller
/0/e4000000/a          eth0       network     DGE-530T Gigabit Ethernet Adapter (rev 11)
/0/e4000000/f          scsi3      storage     VIA VT6420 SATA RAID Controller
/0/e4000000/f/0        /dev/sda   disk        186GB WDC WD2000JS-60M
/0/e4000000/f/0/1      /dev/sda1  disk        Linux filesystem partition
/0/e4000000/f/0/2      /dev/sda2  disk        166GB Extended partition
/0/e4000000/f/0/2/5    /dev/sda5  disk        Linux filesystem partition
/0/e4000000/f/0/2/6    /dev/sda6  disk        Linux swap / Solaris partition
/0/e4000000/f/1        /dev/sdb   disk        298GB ST3320620AS
/0/e4000000/f/1/1      /dev/sdb1  disk        298GB Extended partition
/0/e4000000/f/1/1/5    /dev/sdb5  disk        Linux filesystem partition
/0/e4000000/f.1                   storage     VT82C586A/B/VT82C686/A/B/VT823x/A/C PIPC Bus Master IDE
/0/e4000000/f.1/0      ide0       bus         IDE Channel 0
/0/e4000000/f.1/0/0    /dev/hda   disk        PIONEER DVD-RW DVR-110
/0/e4000000/f.1/0/0/0  /dev/hda   disk
/0/e4000000/10                    bus         VT82xxxxx UHCI USB 1.1 Controller
/0/e4000000/10/1       usb1       bus         UHCI Host Controller
/0/e4000000/10.1                  bus         VT82xxxxx UHCI USB 1.1 Controller
/0/e4000000/10.1/1     usb2       bus         UHCI Host Controller
/0/e4000000/10.2                  bus         VT82xxxxx UHCI USB 1.1 Controller
/0/e4000000/10.2/1     usb3       bus         UHCI Host Controller
/0/e4000000/10.3                  bus         VT82xxxxx UHCI USB 1.1 Controller
/0/e4000000/10.3/1     usb4       bus         UHCI Host Controller
/0/e4000000/10.4                  bus         USB 2.0
/0/e4000000/10.4/1     usb5       bus         EHCI Host Controller
/0/e4000000/11                    bridge      VT8237 ISA bridge [KT600/K8T800/K8T890 South]
/0/e4000000/11.5                  multimedia  VT8233/A/8235/8237 AC97 Audio Controller
/0/100                            bridge      K8M800 Host Bridge
/0/101                            bridge      K8M800 Host Bridge
/0/102                            bridge      K8M800 Host Bridge
/0/103                            bridge      K8M800 Host Bridge
/0/104                            bridge      K8M800 Host Bridge
/0/105                            bridge      K8 [Athlon64/Opteron] HyperTransport Technology Configuration
/0/106                            bridge      K8 [Athlon64/Opteron] Address Map
/0/107                            bridge      K8 [Athlon64/Opteron] DRAM Controller
/0/108                            bridge      K8 [Athlon64/Opteron] Miscellaneous Control

For information on a specific class of device (the classes can be retrieved by the above command) such memory:

sudo lshw -C memory

*-firmware

description: BIOS
vendor: Award Software International, Inc.
physical id: 0
version: FB (12/07/2005)
size: 128KB
capacity: 448KB
capabilities: pci pnp apm upgrade shadowing cdboot bootselect socketedrom edd int13floppy360 int13floppy1200 int13floppy720 int13floppy2880 int5printscreen int9keyboard int14serial int17printer int10video acpi usb agp ls120boot zipboot biosbootspecification

*-cache:0

description: L1 cache
physical id: 8
slot: Internal Cache
size: 128KB
capacity: 128KB
capabilities: synchronous internal write-back

*-cache:1

description: L2 cache
physical id: 9
slot: External Cache
size: 256KB
capacity: 256KB
capabilities: synchronous internal write-back

*-memory

description: System Memory
physical id: 18
slot: System board or motherboard
size: 1536MB

*-bank:0

description: DIMM 400 MHz (2.5 ns)
physical id: 0
slot: A0
size: 1GB
width: 64 bits
clock: 400MHz (2.5ns)

*-bank:1

description: DIMM 400 MHz (2.5 ns)
physical id: 1
slot: A1
size: 512MB
width: 64 bits
clock: 400MHz (2.5ns)

Or to get CPU information:

sudo lshw -C processor


 *-cpu
      description: CPU
      product: AMD Sempron(tm) Processor 2800+
      vendor: Advanced Micro Devices [AMD]
      physical id: 4
      bus info: cpu@0
      version: AMD Sempron(tm) Processor 2800+
      slot: Socket 754
      size: 1600MHz
      capacity: 4GHz
      width: 64 bits
      clock: 200MHz
      capabilities: fpu fpu_exception wp vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 syscall nx mmxext fxsr_opt x86-64 3dnowext 3dnow up pni lahf_lm

Remember to run the command with sudo or you will only get a partial list of results.

WMC Finally Becomes Useful!

2008-01-30T11:33:00.000+10:00

I have a media server onto which I have backed up all my DVDs. And why not? No more searching through my DVD collection, or looking for DVDs which have been misplaced in the wrong covers or worrying about whether my DVDs are scratched.

Anyway, until today on Vista (Home Premium) I had to always use another program such as PowerDVD to watch these movies as Windows Media Center (WMC) did not play DVDs off the hard drive - only movies from an optical drive. So you had a few options, either play the movie from the original DVD or mount your extracted DVD as a virtual drive using tools like Daemon Tools. Both were a little too cumbersome for me given that I had spent all this time extracting all my DVDs to my media server.

I stumbled upon this excellent link that details how to hack WMC to detect and play extracted DVDs. Yay! :) Since I got it working in under 2 minutes, I'll show you how:

1. Open regdit.exe

2. Browse to HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Media Center\Settings\DvdSettings

3. Edit the ShowGallery value and change it from Play to Gallery.

4. Restart your computer (Shock! Horror!) Rumour has it that you needn't restart windows. See what works for you.

5. Once your computer restarts, log in and start WMC. You should have a new option under TV + Movies named dvd library. Previously this was named dvd.

6. Select dvd library. You should see 2 default clips (Apollo13 and Vertigo) that ship with WMC. If you are using the microsoft remote click the i (more) button or if you are using a mouse, right click on an empty portion of the screen. Choose Add Movies from the context menu that pops up.

7. Select Add folder to watch and click Next.

8. Select where you want to add your movie folder from (remote share, local or a mixture). Choose Next.

9. Choose your location(s) and click Finish.

10. In order to get icons for each of your movies you need to save a picture of the DVD cover into the same folder as the VIDEO_TS and AUDIO_TS directories for your movie. This file must be named folder.jpg. Have a search on google image search (or other sources) for a cover picture of your DVD and download it and save it as folder.jpg. You can use a tool like MS Paint (launched by typing mspaint into a run box) or the excellent Paint.Net, to do the conversion.

11. Here's an example of where I have extracted my Undercover Brother DVD to my hard disk and browsed to it through WMC:

I also read about a WMC plugin called My Movies 2 that does all of the above and more. A review can be found here.

Flaky Sound on Vista

2008-01-25T01:01:00.000+10:00

I've got a Creative SB X-fi running on Windows Vista. Support for this card is very flaky on Vista, compared to the support on Windows XP. I've noticed intermittent audio failure on Vista for apparently no good reason! I've since found the culprit to be the Windows Audio Service.

If you find your audio suddenly not working on Vista then:

1. Launch the Services Console (type services.msc in a run box)
2. Right-click on the Windows Audio service and choose stop.
3. Once stopped, then start the service again by right-clicking on the Windows Audio service and choosing start.

If you're lucky your audio should be working again! :)

What is an Algebraic Data Type?

2008-01-21T16:22:00.000+10:00

Tony Morris recently ran an excellent Scala course for some of the guys @ the office. The course really opened my eyes to the power of functional programming languages like Haskell and to the object-oriented/functional programming hybrid - Scala.

Scala leverages all the goodness (or badness- as Tony might say) of Java. One of the main hindrances I found when moving to Scala and any functional programming language for that matter were, the concepts and and the terminology.

In this post, I hope to shed some light on what an Algebraic Data Type is.

Here are some definitions I have found for algebraic data types:

A type defined by giving several alternatives, each of which come with their own constructor. It usually comes with a way to decompose the type through pattern matching. The concept is found in specification languages and functional programming languages. Algebraic data types can be emulated in Scala with case classes. - Programming in Scala

In computer programming, an algebraic data type is a datatype each of whose values is data from other datatypes wrapped in one of the constructors of the datatype. Any wrapped data is an argument to the constructor. In contrast to other datatypes, the constructor is not executed and the only way to operate on the data is to unwrap the constructor using pattern matching. - Wikipedia

"It is using types to define an algebra" - Tony Morris

While all of the above definitions are correct in some form or other, it doesn't make it easy for a new-comer to understand these concepts due to implementation details such as "constructors" , "pattern matching", "case classes". After much deliberation with Tony, we finally came up with a simple definition of an algebraic data type:

"An algebraic data type is a classification"

There. That's very easy to understand. Anything and everything around you can be classified. We do this in Java with classes. For example, Person could be an algebraic data type with Barney and Fred as two elements of that type:


class Person {}
final class Fred extends Person {}
final class Barney extends Person {}

You could use the values of Fred and Barney to figure out which Person element was being used. In Java you could do this by:


if (person instanceof Fred) {
   //do something
} else if (person instanceof Barney){
   //do something else
} else {
   throw new IllegalArgumentException("There are only 2 people. I don't know what you are.") 
}

or if you used an enum:


   public enum Person {
       Fred, Barney
   }

   ...
   ...
   switch (person) {
       case Fred: //do something; break
       case Barney: //do something else; break
       default: //show error
   }

In Scala you could pattern match (select the values of the algebraic data type) with:


person match {
   case Fred => //do something
   case Barney =>// do something else
   case _ => //handle this exceptional case.
}

as you can see it is very similar to switching with an enumerated type in java. One main difference is that you can pull out values from a matched element (deconstruct) if it were passed to its constructor:

if Fred had a constructor of the form:

Fred(name: String, surname: String)

then we could match and deconstruct (pull out parameters) with:


   case Fred(name, surname) => //use name and surname.

Person could be called a closed data type if it defined a finite set of member elements (or closed sum type (to use more mathematical and rigorous terminology) - Tony). For example take a Java enum of Person:


public enum Person {
 
   Fred("Flintstone"),
   Barney("Rubble");

   private final String surname;
 
   private Person(final String surname) {
       this.surname = surname;
   }
 
   public String getSurname() {
       return surname;
   }
}

We know that since we can't extend enums externally that there are only ever 2 Person elements: Fred and Barney. In Scala a closed data type could be implemented with a sealed trait:


sealed trait Person
final case class Fred(surname: String, age: Int) extends Person
final case class Barney(salutation: String) extends Person

   ...
   ...
   person match {
     case Fred(surname, age) => println("Hello Fred " + surname + " your age is " +  age)
     case Barney(salutation) => println("Hello " + salutation + " Barney")
     case _ => println("Who are you?")
   }

Scala lets you define different constructors for each type unlike in Java enums where all elements of a type have to have the same constructors.

This contrasts with an open data type like:


class Person {}
final class Fred extends Person {}
final class Barney extends Person {}

Here Person could have an infinite number of subclasses or elements in its algebraic data type.

Another confusing concept I came across was the Abstract Data Type, which I sometimes confused with Algebraic Data Types. An abstract data type is an algebraic data type (it's a classification) which does not expose the construction details of its elements. In Java it would be something like:


public abstract class Person {
 
   public abstract String getName();

   private Person() { }
 
   private static class Fred extends Person {
       @Override
       public String getName() {
           return "Fred";
       }

   }
 
   private static class Barney extends Person {
       @Override
       public String getName() {
           return "Barney";
       }
   }
 
   public static Person createFred() {
       return new Fred();
   }
 
   public static Person createBarney() {
       return new Barney();
   }
}

Here's an example of an abstract data type in Scala written by Tony for Tom's Obi project:


sealed trait Javac {
   def apply(srcdir: SrcDir): Javac = this match {
       case Javac_(_) => Javac_(Some(srcdir))
   }

   def srcdir(s: String) = apply(SrcDir.srcdir(s))

   def srcdir = this match {
       case Javac_(s) => s
   }
}

private final case class Javac_(srcdir: Option[SrcDir]) extends Javac

object Javac {
   def javac: Javac = Javac_(None)
}

Since the Javac_ class is private the only way to instantiate the class is through the static javac method on the object JavaC.

DVD Ghosting On Vista

2008-01-18T01:20:00.001+10:00

I recently noticed prominent ghosting on my Dell FPW2405, while, watching The Rock on my Vista (Home Premium) box. I hadn't watched a DVD on my PC in a while and I kept second-guessing myself as to whether it was a problem that already existed (with the display) or whether it was something new that I hadn't noticed until now. I was using a Sapphire ATI Radeon x1950 Pro graphics card.

After some cursory research, I came to the conclusion that my Dell FPW2405 was to blame. Strangely enough I didn't have any ghosting on the copious amounts of TV series I watch on a regular basis. Hmmm. I didn't know what was going on and decided to buy a new monitor when the time and price was right.

I recently stumbled across this post which alluded to a fix for problem I was having. After a quick registry hack, I noticed almost a 90% reduction in ghosting while watching DVDs! :) I have since installed the latest ATI drivers and catalyst centre for the graphics card and everything is still working very well!

In summary all you need to do is:

1. Launch regedit
2. Browse to HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Video. There should be a many subfolders beneath this key which have a "0000" subkey. Find the subkey that had child folders (expandable) and browse to 0000\UMD\DXVA.
3. Right-click on the view pane and choose New->String value and create the key values below:

TRDenoise = 0
DXVA_DetailEnhance = 0

4. Restart your computer.

If you have a copy of The Rock , have a look @ the first 10 minutes of the movie where the commandos break into the army artillery. There should be severe ghosting before the fix.

You can't Skimp on HashCode

2007-12-28T16:51:00.000+10:00

I sometimes use hashCode() like it's a necessary evil when overriding equals() (override hashCode() when you override equals() has been drummed into my head over and over again).

The hashCode() method has a few nuances worth noticing. If you ever add your Objects into a hash such a HashSet or a HashMap, it will take precedence over the equals() method when comparing Objects. This is quite subtle and it makes sense when you think about it for a while.

Say you create the ubiquitous Person class with a name, surname and age.


package com.blogspot.babyloncandle;

public final class Person {

  private String name;
  private String surname;
  private int age;

  public Person(final String name, final String surname,
      final int age) {
      this.name = name;
      this.surname = surname;
      this.age = age;
  }

  public String getName() {
      return name;
  }

  public String getSurname() {
      return surname;
  }

  public int getAge() {
      return age;
  }

  @Override
  public int hashCode() {
      return surname.hashCode();
  }

  @Override
  public boolean equals(final Object obj) {
      if (obj == null || !(obj instanceof Person)) {
          return false;
      }

      final Person incoming = (Person) obj;
      return incoming.getSurname().equals(surname);
  }
}

Say we initially state that any Person with the same Sunrname is equal. The hashCode() implementation also returns a value based on the Surname for a Person.

Using Instinct, we could then create a Context for Person to specify that 2 People with the same surname are equal:


package com.blogspot.babyloncandle;

import static com.googlecode.instinct.expect.Expect.expect;
import com.googlecode.instinct.integrate.junit4.InstinctRunner;
import com.googlecode.instinct.marker.annotate.Context;
import com.googlecode.instinct.marker.annotate.Specification;
import org.junit.runner.RunWith;

import java.util.HashSet;
import java.util.Set;

@Context
@RunWith(InstinctRunner.class)
public class APersonContext {

  @Specification
  public void shouldEquatePeopleWithTheSameSurname() {
     final Person person1 = new Person("Humpty", "Dumpty", 5);
     final Person person2 = new Person("Lumpy", "Dumpty", 6);

     expect.that(person1).isEqualTo(person2);

     final Set<Person> uniquePeople = new HashSet<Person>();
     uniquePeople.add(person1);
     uniquePeople.add(person2);

     expect.that(uniquePeople).isOfSize(1);
  }
}

The specification passes with no dramas. Now if we change the hashCode() method of the Person object such that the hashCode is calculated on age:


  @Override
  public int hashCode() {
      return age;
  }

If we rerun the specification, it fails with:


java.lang.AssertionError:
Expected: <1>
   got: <2>

This implies that the uniquePeople Set now has 2 elements instead of 1. This almost seems counter-intuitive as we have not changed the implementation of the equals() method of Person.

Why is the spec failing? It has to do with how equals() and hashCode() works. If 2 Objects are equal they MUST have the same hashCode(). (But 2 Objects with the same hashCode() need not be equal). We have now broken this contract. (as equals() works on Surname and hashCode() works on Age) The implications are more subtle though. The only reason the specification actually failed is because we used a hash implementation (HashSet) to store the 2 Person Objects.

If we add a System.out.Println() to the equals() method of Person, we see that it is never called when it's in the Set. If we add a System.out.Println() to the hashCode() method of Person, we see that it is called for each Person Object within the Set.

This has to do with the way hashing works in Java. The hashCode is used to select a "bucket" into which each Object is added. If Object are in different buckets (meaning they have different hashCodes) they are never compared for equality. This is very important, because, if you go against the equals/hashCode specification, your Objects could never be found in hash implementations. If you revert the hashCode() of Person to use Surname, while retaining the System.out.Println() statements, you'll see that hashCode() is called on each Object before equals().

So it's not just that you should override hashCode() when you override equals() as many people do automatically. (without paying much attention to the hashCode value). You should override it such that you always maintain their contracts or you could end up with hard-to find errors.

Lots of people use a default value (eg. 42) for hashCode(). This satisfies the equals/hashCode contract. It is not so great for hash performance though, as all Objects land in the same bucket increasing processing time.

You also have to be careful between choosing a highly unique hashCode (A bucket per equal Objects of a certain type - this leads to an massive increase of buckets) and choosing a hashCode that is not unique at all (1 bucket for all Objects - this could lead to large processing times). Depending on the performance requirements of your application, you may need to make some compromises on the value of hashCode you choose to return.

Ubuntu: Highlight me Vim

2007-12-23T14:52:00.001+10:00

Vim (Vi Improved) gives you many features over that of the standard Vi feature set such, as syntax highlighting, incremental searching, bracket matching and many others. Here's how to install Vim for Ubuntu:

1. Run sudo apt-get install vim from a command prompt.
2. Copy the the default vimrc file from /etc/vim to your home directory with with the name .vimrc

cp /etc/vim/vimrc ~/.vimrc

3. " denote commented features. Uncomment any features you want to turn on. To turn on syntax highlighting change "syntax on to syntax on.

4. Open a java file to see the highlighting in action:

vim yourfile.java

5. If you get the following error:

E319: Sorry, the command is not available in this version: syntax on

it means that you haven't installed vim properly and that you are using tinyVim which, comes standard with Ubuntu. Install Vim as per Step1 again and look out for any errors.

The following is a list of features I use:


" This line should not be removed as it ensures that various options are
" properly set to work with the Vim-related packages available in Debian.
runtime! debian.vim

" Vim5 and later versions support syntax highlighting. Uncommenting the next
" line enables syntax highlighting by default.
syntax on

" If using a dark background within the editing area and syntax highlighting
" turn on this option as well
set background=dark

" The following are commented out as they cause vim to behave a lot
" differently from regular Vi. They are highly recommended though.
set showcmd        " Show (partial) command in status line.
set showmatch        " Show matching brackets.
set ignorecase        " Do case insensitive matching
set smartcase        " Do smart case matching
set incsearch        " Incremental search
set autowrite        " Automatically save before commands like :next and :make
set hidden             " Hide buffers when they are abandoned
set mouse=a        " Enable mouse usage (all modes) in terminals

" Source a global configuration file if available
" XXX Deprecated, please move your changes here in /etc/vim/vimrc
if filereadable("/etc/vim/vimrc.local")
 source /etc/vim/vimrc.local
endif

"this line is a comment .... one which begins with double-quotes
" The best is the bold font, try all of these and pick one....
set guifont=8x13bold
"set guifont=9x15bold
"set guifont=7x14bold
"set guifont=7x13bold
"
" Highly recommended to set tab keys to 4 spaces
set tabstop=4
set shiftwidth=4
"
" The opposite is 'set wrapscan' while searching for strings....
set nowrapscan
"
" The opposite is set noignorecase
set ignorecase
set autoindent
"
" You may want to turn off the beep sounds (if you want quite) with visual bell
set vb

Configuring Eclipse Plugins May Cause Trauma, defection to Intellij

2007-12-21T01:13:00.000+10:00

I've been trying to use Eclipse in an environment where Intellij was and is the IDE of choice. I hate to say it but, basic Eclipse plugins (such as for subversion and checksyle) are annoying to configure and use. Eg. The first thing that I was greeted with after installing the Subclipse plugin was a huge error message. Not exactly the confidence-building outcome you would expect.

The plugins also take multiple steps to do somewhat simple configuration. While recently using a Checkstyle plugin (Eclipse-CS) I was forced to configure it via 3 separate routes for all the settings to take effect! (One through Windows->Preferences, one through Project properties, and one through the context menu) This is obviously way to hard for the average user, who would readily turn to Intellij where basic plugins are very easy to setup, requiring little configuration.

I'm currently working on Instinct which was primarily developed using Intellij. We are now catering for Eclipse developers and want an even playing field for users and developers alike.
To this end I've been creating how-tos on using basic plugins for Eclipse.

I am quite pleased with the progress Eclipse has made in the last few years and don't think Intellij is miles ahead of it as it was maybe 3 years ago. What we need are better plugins and more userfriendly features.

The Harry Potter culture of Wizardry has got to stop! Wizards may seem to make your life easier initially but in the long run they make everything more prolong and confusing. Why click through 5 screens when you can set all your options in one place?

I also found that shortcut keys could not be associated with these plugins in Eclipse, while Intellij lets you define shortcuts even for plugins. All pretty basic really. Why right click, click and click again when you can simply press a shortcut in 1/2 the time?

How-tos on installing and configuring Subclipse and Eclipse-CS can be found below:

Installing and configuring Subclipse
Installing Eclipse-CS

Wireless Apple Keyboard on Vista

2007-12-04T21:13:00.000+10:00

I recently purchased an Apple wireless keyboard. I blame it on being surrounded by Mac evangelists at the time. I had the quaint notion of using the keyboard on my Windows Vista box. To cut a long story short, I spent around a week trying to get the keyboard paired with my Asus bluetooth dongle (WL-BTD201M) and although I did succeed, the results were less than satisfactory. This was due to many reasons such as the keyboard being a Mac keyboard and Vista's flaky support for bluetooth. I say flaky because pairing the keyboard with a MacBook took around 20 seconds! I experienced unreliable bluetooth functionality on Vista with the connection reset every so often - too often to make it usable. Unlike other components on your system, if your keyboard or mouse is non-functional it gets frustrating pretty fast.

Here's what I liked about the apple keyboard:

1. Very small. See pic against my Microsoft keyboard.
2. The keys are very nice to the touch and spaced exactly right.
3. The bluetooth connection light emanates from an almost invisible led on the keyboard.
4. The packaging was fantastic as per usual Apple standard.
5. The keyboard is one of the thinnest and lightest keyboards I have ever seen. See pic.

Here's what I disliked about it:

1. It was maybe too small. I found it hard to type with it at times. But then again if you have smaller hands than I do, I doubt this will be a problem.
2. It was missing some important keys I frequently use like home, end, insert, backspace, page up/down and printscreen to name a few! I was told that home and end keys were (command + <-) and (command + ->) on the Mac, which is great if I could only find some software to do the mapping for me.
3. Some of the keys like the function key (fn) didn't work out of the box and needed special software to work. The remaining keys can be mapped with a tool like SharpKeys.

Here are the steps I followed to get the keyboard paired on Windows Vista:

This guide is for dongles using the Widcomm bluetooth stack only. You need another working keyboard (preferably wired) for use to enter the pin code.

1. Remove the following updates if installed:

Update 941600 (Cumulative update rollup for USB core components in Windows Vista)
Update 941649 (An update that improves the compatibility, reliability, and stability of Windows Vista)

2. Install the Widcomm drivers that came with your bluetooth dongle.
3. Launch regedit.
4. Locate the HKEY_CURRENT_USER\Software\Widcomm\BtConfig\General key.
5. Set the key PinCodeWord to a decimal value of 1111
6. Set the key UseFixedPin to a decimal value of 1
7. Set the key NoSleepingWhileConnected to a decimal value of 1 (Disallows the keyboard going to sleep while connected to via bluetooth)
8. Set the key DeviceInactivityDuration to a decimal value that represents the time in seconds before the keyboard disconnects from the bluetooth dongle. Eg. A value of 10800 is 3 hours. (60x60x3)
9. Set the key MinPINLength to a decimal value of 3. This is the minimum pin code length).
10. Restart the computer and log in with your other keyboard (not the Apple keyboard).
11. Attempt pairing the keyboard with the dongle. Once the keyboard is detected, select it and click next to proceed. On the next screen you will need to enter a pairing key, which you won't be able to enter! :) The key you entered into the registry at step 5 is what you need to enter here. Using your other keyboard type in the pin code. You will not see the key strokes but they will be entered into the dialog.
12. Press the Return key on the Apple keyboard.
13. The bluetooth authentication dialog should accept this value. If it doesn't your probably entered the wrong passkey. You may have to repeat the pairing process a few times before it succeeds.

If and when the keyboard disconnects, I use the bluetooth driver in Vista to disable and enable bluetooth (using the mouse since my keyboard is not working). This then redetects the keyboard and reconnects to it in about 10 seconds. Failing this I eject and reinsert the dongle after about a 10 second wait.

JPA - Not Another API (NAA)?

2007-12-02T21:08:00.000+10:00

I've recently started looking at JPA (Java Persistence API). I must admit I was a little annoyed. I already knew how to use hibernate and it suites most purposes. So why learn yet another annoying Sun API?

You can use JPA in EJB3 which really standardizes EJB persistence - this is a good thing. Fantastic. What if you avoid EJB technologies like the plague? Why do you need yet another API to handle standalone data persistence?

While looking for resources to get my first JPA project off the ground, I was pleasantly surprised by 2 excellent how-tos. One with Hibernate and one with TopLink. It seems very easy and it has much of the goodness of Hibernate - so it's not all bad! :)

Unfortunately it doesn't seem to have anything similar to the Criterion API in Hibernate. (I could be wrong - if so please let me know!) The Hibernate implementation also offers a few niceties which in my opinion subvert the JPA by making things "automatic". Obviously if you switch JPA providers this magic won't work - so it's not really standard. Hmmm. A non-standard use of standardized API. Wot tha?

A main driving factor for me learning JPA was the that Spring 2.5 only supports JPA and not the "old-school style" Hiberate templates. Hiss! Boo! Since many of the big players (Sun, Spring etc) are moving to JPA, it seems like a good time to learn to reinvent the persistent wheel!

As with any new API, the hardest part is to get your first "hello world" application running. I found 2 simple how-tos on JPA to help you get started:

HelloWorld JPA example in TopLink
HelloWorld JPA example in Hibernate 3

Running Leopard on a PC

2007-11-16T18:38:00.000+10:00

Stop the press! There is an updated non-hackety guide here. The hackety guide is outlined below:

There is an excellent LifeHacker article on how to run Leopard (Max OS 10.5) on a regular PC! :) So hopefully we can get all the goodness of a Mac (Tom Adam's anyone?) without all the proprietary hardware crapiola of an Apple! Yay! Give the guide a go here.

Pair Programming : Compatibility of a Pair Really Matters

2007-10-30T07:47:00.000+10:00

I've been a practitioner and supporter of Agile methodologies for a few years now and most of the time I think it's great. TDD/BDD (Test-Driven Development/Behaviour-Driven Development) and Pair Programming are import tools in one's Agile tool set.

Recently I've been pairing in Java with some very intelligent guys from a Ruby and C++ background. This obviously made for some very interesting pairing. Being primarily from a Java background myself (having left C++ in the dust over 5 years ago) I've become accustomed to certain niceties in Java. A single class with a single purpose, meaningful method and variables names, refactoring, IDE support and most importantly testing/specing code before writing it are some of the more important ones.

These concepts blend very well with someone with a Ruby background mainly because they use some or all of these concepts and have other great concepts that Java could adopt. Unsurprisingly, pairing with the Ruby guys was very productive and the code fairly well designed and implemented.

In the last week I've been pairing with someone from a pure C++ background and the results have been mixed. Pure C++ programmers are eager to come up with the "best" the solution to a problem immediately. No TDD/BDD, no testing/specing - just full steam ahead! I feel this is anti-agile, as you have preconceived notions about how the code should be written before even writing it. This leads to a somewhat haphazard "design" and hence complicates everything from this point onward. When TDDing/BDDing, we drive out a good design through tests/specs and by bypassing these steps we loose out on this benefit.

The other important difference I saw between pure C++ and C++/Ruby programmers was that it was more challenging to get the pure C++ programmer to write even the simplest test/spec. "Why do we need it?", "I know what the solutions is", "This is a waste of time" were some of the usual comments that one could hear floating around. These are all valid questions/statements. But it hinders more than helps when you have to constantly justify to someone why testing/specing is good. This definitely slows down any forward momentum. I feel that anyone doing pair programming should at least have a cursory understanding of the benefits and drawbacks of TDD/BDD.

Another facet of pure C++, namely writing the most efficient solution upfront is another hurdle to jump over when pairing. Premature optimization usually leads to very hard-to-maintain code. I find it very hard to get someone out of this mindset when programming in a language like Java. Long variables and method names look ridiculous to pure C++ programmers because this is not what they are used to. Soon it becomes a struggle. You want to name everything in the most readable way possible while the pure C++ programmer wants to name everything as terse as possible. You want to have more classes with a single purpose, they want to have less classes which were are compact as possible. You want to reduce complexity, C++ programmers are "used to" complexity and don't have problem with it. What to do, what to do?!

As with anything in life, there has to be some give and take. All taking and no giving does not make anyone happy...well....almost no one! :) So you have to make sacrifices (at the Java alter of goodness) and win wars and fore go battles. Corners get cut and your confidence in the code and that warm fuzzy feeling begins to dwindle.

So at the end of the day, the question is, how good is your solution when you have such forces competing in opposite directions? I would say less than optimal. Did we get a working solution ? Yes, definitely. Is it something I thought was great and easy to understand and maintain? Probably not. Was it something the pure C++ programmer thought was efficient and the most elegant solution? Probably not. So was this a win-win situation for the customer and programmers involved? Probably not.

So the point to my long rambling is this: The effectiveness of pair programming depends on who you are pairing with, their technical background, personality, work ethic and how much they like working in a "team". To get the best out of a pair I definitely feel that these factors should be considered before pairing together 2 individuals to solve any business problems.

Ubuntu: Installing the latest JDK or JRE

2007-10-20T01:14:00.001+10:00

In this tutorial I will show you how to install the latest JDK or JRE on your Ubuntu box. I am using JDK1.6 update 3 on Ubuntu 7.0.4 (64-bit) on an AMD64 CPU for this tutorial.

Commands are in bold and blue, paths are in bold while user input and program output are in green italics.

1. Check your current version of java with:
java -version

This should give you something similar to:
java version "1.4.2" gij (GNU libgcj) version 4.1.2 (Ubuntu 4.1.2-0ubuntu5) Copyright (C) 2006 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

If you have the default Ubuntu JRE installed.

2. Download the latest bin file for the java version you require (for linux) from Sun. (Ensure you get the correct bit version for your operating system (32 or 64)). I used Jdk1.6 update 3 for 64-bit linux running on an amd64 cpu. (jdk-6u3-linux-amd64.bin)

3. I usually install all shared software under /opt. Copy the downloaded bin file into /opt with:
cp Desktop/jdk-6u3-linux-amd64.bin /opt

assuming you downloaded the file to your desktop. If not use the correct path to your bin file in the above copy statement.

4. Make the bin file executable with the following:
sudo chmod 777 jdk-6u3-linux-amd64.bin

Enter your user's password when prompted. Check that the above command succeeded with:
ls -l jdk-6u3-linux-amd64.bin

The output should be similar to the following:
-rwxrwxrwx 1 root root 62140783 2007-10-20 01:03 jdk-6u3-linux-amd64.bin

We are interested in the last x in the list of privilege which specifies that all users can execute the bin file.

5. Run the bin file as sudo:
sudo ./jdk-6u3-linux-amd64.bin

This should bring up Sun's documentation with a --More-- displayed at the bottom.

Use the enter key to navigate to the bottom of the document. When asked whether to accept the conditions type:
yes

This will extract the bin file into the /opt directory, creating a jdk1.6.0_03 directory. If you did get permission errors while running the bin file ensure that you ran the bin file with sudo and that you are in the admin group of the machine on which you are installing java.

6. Create a symbolic link to the installed java version with the following from the /opt directory:
sudo ln -s jdk1.6.0_03 jdk16

This will create a symbolic link to the jdk1.6.0_03 directory through the jdk16 directory. A sybolic link is similar to a shortcut in Windows. It provides an alias to directory. The benefit of this is that if you install the next latest version of java you can simply update the symbolic link to that version and all your programs that refer to jdk16 will work with the latest version of java.

Verify that the symbolic link has been created with following from /opt:
ls -l

The jdk16 -> jdk1.6.0_03 signifies the symbolic link.
lrwxrwxrwx 1 root root 11 2007-10-20 01:05 jdk16 -> jdk1.6.0_03

7. Now we need to update PATH and JAVA_HOME variables for your user. Edit the .profile file found in your home directory (home/your_user) with a text editor such as vi or gedit:
vi ~/.profile or
gedit ~/.profile

(~ denotes your home directory)

Add the following lines to the bottom of this file:

export PATH=/opt/jdk16/bin:$PATH
export JAVA_HOME=/opt/jdk16

save and close the file. The .profile file is run when you log into the system. So the next time you login the PATH and JAVA_HOME variables will be set appropriately.

8. Logout of your user and log back in. You can do this in the GUI or simply type:
logout
if you are connecting through a terminal.

9. Log back in with your user.

Verify that the PATH is set to the jdk bin directory by typing the following:
env | grep PATH

This should give you something like:
PATH=/opt/jdk16/bin:/usr/local/sbin:/usr/local/bin

Make sure the /opt/jdk16/bin is the first path entry.

Verify the JAVA_HOME variable with the following:
env | grep JAVA_HOME

this should give you the following:
JAVA_HOME=/opt/jdk16

Now verify the java version with:
java -version

You should get something similar to the following:
java version "1.6.0_03" Java(TM) SE Runtime Environment (build 1.6.0_03-b05) Java HotSpot(TM) 64-Bit Server VM (build 1.6.0_03-b05, mixed mode)

10. Congratulations, you have now installed the latest version of java! :)

How Wacky can Windows Get?

2007-10-15T19:20:00.000+10:00

Yeah, don't answer that. I was recently copying some files from my digital camera and got this surprisingly astute message:

Unfortunately, I won't be alive for another 21860 days (59 years) until 321 MB is copied from my memory card, well maybe... What to do? What to do? :P

Ubuntu: How do I find out my Ubuntu version?

2007-10-07T22:21:00.001+10:00

Type lsb_release -a at a command prompt. This will give you information about the version of Ubuntu that is running plus it's code name etc. Type uname -a get information about whether you are running 32-bit or 64-bit Ubuntu.

This shows information about the 64-bit (or x86_64) Ubuntu 7.0.4 (Fiesty).

This shows information about the 32-bit (or 686) Ubuntu 6.10 (Edgy).

Welcome

2007-10-06T11:55:00.000+10:00

Welcome to the Babylon Candle! The "Babylon Candle" is a concept I "borrowed" from the movie Stardust. A Babylon Candle allows the owner to transport him/herself anywhere in the world just by focusing on that location. So it doesn't make much sense for a blog name, but it does sound cool! :)

This blog will focus mainly on development related articles using Java, Windows (Shock! Horror!) and Ubuntu. Being a mostly windows programmer I moved to Ubuntu around 6 months ago. The learning curve has been pretty steep, but I'm moving all my machines to Ubuntu one by one. I hope to blog some general how-to's with Ubuntu specially for that windows user who has made the recent move.

- Sanj