class ChessGame {
    // Some instance variables
 
    public ChessGame (Player player1, Player player2, int timeLimit) {
        this.player1 = player1;
        this.player2 = player2;
        this.timeLimit = timeLimit;
    }
 
    public void playGame() {...}
}
 
class ChessGameTest {
    @Test
    public void testChessGamePlaysForXseconds () throws Exception {
        Player player1 = createMock(Player.class);
        Player player2 = createMock(Player.class);
 
        Handicap handicap1 = new Handicap(10, Rules.Standard);
        Handicap handicap2 = new Handicap(4,  Rules.Standard);
 
        expect(player1.getName()).andReturn("D. Duck");
        expect(player2.getName()).andReturn("M. Mouse");
 
        expect(player1.getHandicap()).andReturn(handicap1);
        expect(player2.getHandicap()).andReturn(handicap2);
 
        replayAll();
 
        new ChessGame(player1, player2, 10).playGame();
 
        // Assertions ....
    }
}

The problem here is that we’ve specified dependencies on far too many objects and values! By asking for two Player objects, you’re essentially saying “give me two objects which have names, ages, total scores, rankings, biographies, etc… and which also have very detailed Handicap information”.

Ask yourself this question:

• Without looking inside the class file, what exactly does the ChessGame need in order to execute playGame()?

It’s not at all obvious is it! My guess would be that we only really need player names, and handicap information (why do we need the player bio to play a match??). If this is the case, why do we pass all that extra information to the ChessGame constructor, if it’s never going to need it?

I can hear you answering “But it’s far more convenient to package up that information as it exists naturally – inside the Player object. It is more readable, and keeps the number of constructor parameters down!”

But this is not a valid reason because of the following:

1. Classes should not ask for more information than they need – otherwise they become difficult and cumbersome to test
2. Classes should make absolutely clear what their dependencies are. This is why passing around “Contexts” is a bad thing

We can make this a lot easier by using a Factory Method as a convenience:

class ChessGame {
 
    public ChessGame (String player1Name, String player2Name, 
                int player1Handicap, int player2Handicap, int timeLimit) {
 
        this.player1Name = player1Name;
        this.player2Name = player2Name;	
        //..etc
    }
 
    public static ChessGame withPlayers (Player player1, Player player2, int timeLimit) {
        return new ChessGame (
            player1.getName(), 
            player2.getName(),
            player1.getHandicap().getAbsolute(),
            player2.getHandicap().getAbsolute());
    }
 
    public void playGame() {...}
}
 
class ChessGameTest {
    @Test
    public void testChessGamePlaysForXseconds () throws Exception {
 
        new ChessGame("D. Duck", "M. Mouse", 10, 4, 10);
 
        // Assertions ....
    }
}

The second ChessGame class accepts only what it needs – it has fewer dependencies on real objects. However, we now have a nice convenience method on the object which takes our existing objects.

Why stop there? Here are some more Factory Methods which you might prove useful:

public static ChessGame fromExistingGame (ChessGame previousGame) {...}
public static ChessGame againstBot (BotFactory botFactory) {...}
public static ChessGame fromDataFile (File dataFile) {...}

So in conclusion – if you’re finding yourself setting up tonnes of scaffolding for a test, ask yourself whether the unit-to-be-tested is asking too much of you!

A common problem arises when you need to change the underlying implementation of a class, and you want to use your existing tests to assert that the outward behaviour of this class has not changed. You may well take the following approach:

1. Make changes to your class implementation
2. Fix any tests that have broken
3. Re-run the tests. Do they pass?

Can you spot a problem with this approach? When you change your tests, you cannot rely on them to validate your code anymore. The point of verifying change using Unit Tests is that they remain an invariant. If you have changed both your code and your tests, then you have no confidence that you haven’t introduced a bug in your work!

Look at the code sample below:

    @Test
    public void testTwoCorrectAnagramsAreGenerated() throws Exception{
 
        // Given : a basic anagram generator
        // When : presented with the word "sleep"
        WordList wordList = new AnagramGenerator().generateAnagrams("sleep");
 
        // Then : we get two anagrams - "sleep" and "peels"
        List words = wordList.getWords();
        assertEquals("First anagram", "sleep", words.get(0));
        assertEquals("Second anagram", "peels", words.get(1));
        assertEquals("Size", 2, words.size());
    }

This simple test is flawed:

1. We are assuming that the implementation of WordList will always store its words in a List<String>. In fact, we are forced to expose the underlying structure of our object.
2. The test will fail if we change the order in which the anagrams are returned. Should the order of the returned anagrams really be a concern in this situation?
3. WordList has become a central focal point of our test, even though we are testing the AnagramGenerator

    @Test
    public void testTwoCorrectAnagramsAreGenerated() throws Exception{
 
        // Given : a basic anagram generator
        // When : presented with the word "sleep"
        WordList list = new AnagramGenerator().generateAnagrams("sleep");
 
        // Then : we get two anagrams - "sleep" and "peels"
        assertEquals("Anagram List", new WordList("sleep","peels"), list);
   }

The result is that we have a smaller test, which doesn’t poke around inside the WordList class when making assertions. The only thing we need to assume is that Object.equals(Object) has been implemented correctly (testing this can be done separately in WordListTest).

Furthermore, if we decide that ordering of results is not important, we can have WordList implement a HashSet. The .equals() method will therefore not check for ordering.

Using equality rather than introspection will ensure that your tests are less brittle and invariant to change. Happy TDDing!

And that’s where poker comes in. Texas Hold’em may or may not be your cup of tea, but it is a game to perfectly test your understanding of the languages you are writing in.

Just look at the different elements that come into play:

• Scoring hands. This is a non-trivial task that is on the surface, quite straightforward with OO. But scoring hands is perfect for functional languages. For extra difficulty, remember – Ace is both high and low!
• Who wins what? With varying players in the game, and varying amounts in the pot, this could get tricky!
• Performance. Ok, so you’ve worked hard on your perfect card-scoring functions. Now we can really test how well you’ve done by asking “how many hands can we score per second?”.
• DSLs. Perhaps the language you are using is good for developing DSLs. Could you write a DSL that mimics a hand of poker? One round? Or even an entire poker game? Something such as the following would be a start (I’m pretty sure Scala’s implicit type conversions will perform this miracle):

“AC QH 10S 2D 4C 8D AD” vs “3S 10C 3C 5H QD QS 7S”

• AI. If you’ve played poker, you know it can be an infinitely complex game of deep strategy. But even a simple A.I. bot can give a player a good run for his money. Start with the basics (hand strength, pot odds, outs) and go from there.
• Immutability. Can you complete your program whilst keeping it completely immutable? I don’t mean scores, chips, etc. I mean, can you avoid mutable data structures, state-ful functions, etc.

Once I’ve written a basic poker engine once, it becomes easier to use it as a comparison between languages. I have a firmer understanding of which languages perform better in which circumstances. Oh, and it’s definitely more fun than writing business applications!

And that’s all I’m going to say; I won’t run comparisons against other popular IDEs, because that’s a subject for another day. Today, I want to talk about sharpening your skills with IDEA.

Shortcuts

We all know that shortcuts improve our productivity. Here are the ones I find most valuable:

• CTRL-W and CTRL-SHIFT-W: Select progressively greater / lesser levels of code
• CTRL-ALT-V: Introduce Variable. See also Introduce Field / Constant
• type “iter” TAB: Java 5 style for loop Live Template. See sections below for more info on this
• ALT-LEFT and ALT-RIGHT: View previous / next tab.
• CTRL-ALT-LEFT and CTRL-ALT-RIGHT: Back / Forward Tab (in history).
• CTRL-N and CTRL-SHIFT-N: Find Class and Find File.
• ALT-F12: Show class outline (press again to also show Inherited members).
• CTRL-D: Duplicate Line.
• F2 and SHIFT-F2: Go to next / previous error (or warning).
• ALT-INSERT: Create new file popup.
• CTRL-SHIFT-F: Find in path.
• CTRL-ALT-T: Show list of Live Templates.
• ALT-ENTER: Show Intentions (see below for more info)

Live Templates

Live Templates are snippets of code you can insert in and around pieces of code. The most common one would probably be “Surround with If”, which takes the highlighted code and surrounds it with an If statement. What’s more, it formats the code correctly so you needn’t worry about tab spacing.

Another good Live Template is the for loop generator. Type “iter” and then hit TAB. IDEA intelligently selects a list of collections you might wish to iterate over:

To create you’re own templates, I would recommend you take a look at this Jetbrains blog post describing how to create a null-check template.

Quick Lists
You can create a shortcut to open a popup of commonly used items of your choosing. Within Preferences, go to Quick Lists to define a new list, and then Key Intentions to create a shortcut for that list. As an example:

Intentions
Intentions can be used to perform common actions, or solve problems with your code. Hitting ALT-ENTER over a valid piece of code will give you common actions. Doing the same over an error will give some suggestions such as:

• Migrate Type
• Cast expression
• Import unknown symbol

Below is an example of both forms of intention:

Oracle doesn’t do this when it comes to Weblogic 10.3. Instead, you can either use educated guesswork in combination with some useful documentation. Or you can use WLST – the Weblogic Scripting Tool.

Using the Weblogic Scripting Tool
The first thing to do is find the binary. This is located here:

%BEA_HOME%/common/bin/wlst.bat <-- Windows
%BEA_HOME%/common/bin/wlst.sh <-- Unix

Start the executable, and wait until you receive a prompt. There is a list of common commands you will need:


connect('username','password','host:port')
serverRuntime()
cd('beanName')
ls()

As you can see, you will be familiar with the commands if you have ever used a unix command prompt before. Be aware that we execure the commands like functions, within brackets, with a number of arguments.

Example

Welcome to WebLogic Server Administration Scripting Shell

snip....
-r-- ActivationTime 1267615098514
-r-- AdminServer true
-r-- AdminServerHost 127.0.0.1
-r-- AdminServerListenPort 7001
-r-- AdminServerListenPortSecure false
-r-- AdministrationPort 9002
snip....


The first list of items are child MBeans. The second list are attributes.

We can navigate to our JDBC connections like so:


wls:/vfdomain/serverRuntime> cd('JDBCServiceRuntime/myserver/JDBCDataSourceRuntimeMBeans/mydatasource')
wls:/vfdomain/serverRuntime/DBCServiceRuntime/myserver/JDBCDataSourceRuntimeMBeans/mydatasource> ls()
snip...
-r-- ConnectionDelayTime 97
-r-- ConnectionsTotalCount 144
-r-- CurrCapacity 10
-r-- CurrCapacityHighCount 11
-r-- DeploymentState 2
-r-- Enabled true
-r-- FailedReserveRequestCount 0
-r-- FailuresToReconnectCount 0
-r-- HighestNumAvailable 12
-r-- HighestNumUnavailable 0
-r-- LastTask null
-r-- LeakedConnectionCount 0
-r-- ModuleId mydatasource
-r-- Name mydatasource
-r-- NumAvailable 10
-r-- NumUnavailable 0
-r-- PrepStmtCacheAccessCount 7836
-r-- PrepStmtCacheAddCount 3808
-r-- PrepStmtCacheCurrentSize 99
snip...


Next job – Firewire cable!

Like most DSLRs the in-built flash leaves a lot to be desired, so I try to use it as little as possible. There are times however, when I just can’t get away without shooting with it. I don’t want to purchase an external flash unit because for me that would detract from the very reason for purchasing a Micro Four Thirds camera in the first place – portability.

Then I stumbled upon the following solution from DIYPhotography.com. The plan is simple – wedge a small piece of white card into the opening of the flash, so it is angled 45 degrees to the flash pointing upwards. The card should extend the width of the flash unit, and preferably just beyond the top, like so:

Simple – a 2 minute job!

I took a couple of test shots – all with the same shutter speed / ISO / aperture. I took them indoors in low light, where the default exposure would have failed to produce acceptable photographs. I haven’t adjusted the images in any way. Here are the results:

The results are pretty conclusive. I would never have been able to shoot at ISO 100 indoors in low light, particularly at 1/80 without a flash. Now I can get realistic skin tones, background detail, and no more “rabbit in the headlights” look. You might get some funny looks, but you’ll appreciate those superior photos.

Automatically scan online job postings for keywords commonly related to certain job titles. In this example, we see what skills are commonly required of a “Web Developer”

I’ve been playing with Groovy and HTTPBuilder lately, using them to get JSON from open web services to use in mashups.

I also started thinking about jobs (to my current employer – no, I’m not looking for a new one). Wouldn’t it be useful to know what skills are being demanded in the current job market. For example, being a Java developer at heart, should I be learning Ant or Maven? What about EJB3 or Spring? How about .NET – do many jobs ask for both?

Below, I’ve written a simple Groovy script to get job postings off the job site AuthenticJobs.com (simply because they had an public API with no hurdles to jump).  With those postings, the program will search the job description for keywords, and see which ones come out on top. This is by no means scientific, but it could make a useful tool for anyone in the job market, especially a newcomer such as a Graduate.

First, we must set up a new HTTP request:

import groovyx.net.http.HTTPBuilder
import static groovyx.net.http.Method.GET
import static groovyx.net.http.ContentType.TEXT
import net.sf.json.groovy.*
 
@Grab(group='org.codehaus.groovy.modules.http-builder', module='http-builder',
   version='0.5.0-RC2')
@Grab(group='net.sf.json-lib', module='json-lib', version='2.3', 
   classifier='jdk15')
 
def http = new HTTPBuilder('http://www.authenticjobs.com');

Notice the use of the Grab annotation. This is a nice feature within Groovy called Grape, which connects to the internet and downloads all the dependencies for the project. In this case, we need a JSON library, and the HTTPBuilder library.

Now we will issue an HTTP request to the AuthenticJobs webservice. We will ask for a list of fifteen matches, with keywords “Web Developer”, in JSON format:

def data = null;
 
http.request(GET,TEXT) {
    uri.path = '/api/'
    uri.query = [api_key:"++++hidden++++",
                  method: "aj.jobs.search",
                  keywords: "web developer",
                  perpage: "15",
                  format:"json"]
 
    response.success = {resp,unformatted ->
       data = unformatted.text;
    }
  }

Now lets parse the data into JSON format so we can extract the job descriptions:

def json = new JsonSlurper().parseText(data)

Let’s define some variables which we will use when processing the JSON. You will see that we are doing a match on list items (bullet points). It’s not unfair to reason that most of the “skills” we wish to extract will be mentioned in bullet-pointed lists.

def words = [:]      // This is where we store the keywords
def match = "<li>([^<]+)</li>"             // Where to look within the description
def filter = ["and","to","in","of",             // Common words to remove
                  "a","with","the","one",
                  "at","it","for","as","on",
                   "be", "or", "is"] 
def junk = [",","—","."]                           // Some junk to filter out

Finally, the processing below:

json.listings.listing.each {
  job -> job.description.toLowerCase().split("\r\n").findAll {it =~ match}.each {
    def matcher = (it =~ match);                            // Find all bullet points
    String allWords = matcher[0][1];
    junk.each {allWords = allWords.replace(it,"")}    // Remove junk chars
    allWords.split().each {                                       // Split into individual words
        word -> words[word] = 
                 (words[word] == null) ?  1 : words[word] + 1 }
    }
}
filter.each {words.remove (it)}                               // Take out common words
words.sort {a, b -> b.value <=> a.value}.each {       
    k,v -> print " (${k}, ${v}) "                                 // Sort in descending order of relevence
}

Here is my output from running the above for the string “Web Developer”:

(experience, 28) (web, 14) (knowledge, 12) (javascript, 11) (design, 11)
(development, 10) (css, 8) (must, 8) (strong, 7) (media, 7) (have, 7)
(working, 7) (php, 6) (skills, 6) (ability, 6) (using, 6) (sites, 6)
(html, 5) (understanding, 5) (xhtml, 4) (familiarity, 4) (other, 4)
(interaction, 4) ((we, 4) (this, 4) (has, 4) (user, 4) (work, 4)
(use, 4) (accessibility, 3) (seo, 3) (plus, 3) (communication, 3)
(new, 3) (technologies, 3) (creative, 3) (clean, 3) (email, 3)
(interface, 3) (jquery, 3) (creating, 3) (website, 3) (their, 3)
(building, 3) (photoshop, 3) (cross-browser, 3) (ajax, 3)
(excellent, 3) (able, 3) (programming, 3) (please, 3) (will, 3)
(front-end, 2) (development;, 2) (least, 2) (tools, 2)
(adobe, 2) (fluency, 2) (best, 2) (practices, 2) (visual, 2) (verbal, 2)
(interpersonal, 2) (desire, 2) (learn, 2) (projects, 2)
(code, 2) (wordpress, 2)

Let’s analyse some of what we have found above:

• Clear skill requirements are Javascript, CSS, PHP, XTML
• It is good to see that the industry rates accessibility as must-have
• This could be a tenuous observation, but experience comes well above both skills and ability combined
• Soft-skills have found their way onto the list as much as hard-skills. Indeed the days of pure computer geek-ery are over

Once again I want to point out the unscientific nature of this experiment.

AuthenticJobs ask users of their API to limit the number of requests to something reasonable, so caching would probably be a good strategy to use here, though I have left it out for brevity. I invite people to take what I have written here and use as they see fit.

Hope you find it useful!

Before we start, I want to give a very quick definition of a Neural Network. It is far from being accurate and all-encompassing, but it will give you enough to get you through this tutorial. For now, this is what you need to know:

A Neural Network is a “machine” which takes an input and approximates a desired output, based on what it has been “trained” to do.

Symbol Processors and Elementary Mathematics

When we were first taught about basic functions in Maths class, we were asked to think of them like a “machine” or a “black box”. You feed a number into this box, and receive a different number out, depending on what the function was supposed to do. For example, a function named “Plus 2″ would take any input and return that input + 2.

A simple "function" as taught in elementary Maths classes. Notice the function being approximated is static and hard-coded

This is what we’ve all implicitly known as a Symbol Processor. Feed in symbol, operate on it, receive a new symbol.

Not too far down the road we were shown more complex examples, such as non-linear functions. Using a suitably complex non-linear function, you could get your “machine” to return any output you see fit. We were also shown functions that had more than one input:

Same again, but non-linear and multiple inputs

On a side note, this is how the preceding function might be written in Groovy:

[[1,8],[2,7],[3,6]].collect { it[0]**-2 + Math.E**it[1] };

Learning through doing

But what if we want do describe a particular function for which we do not have an equation, but instead a set of example data. E.g. we know what output values we want to receive from a particular set of inputs, and would like the function to approximate this (and fill in the gaps as best it can).

This is where Neural Networks come into play. Think of one of these as a moldable function, which we shape by through training.

For example, lets pretend we wanted to create a function which simulated the thought processes of a pet Gorilla. It takes inputs in the form of thoughts and ideas, and returns what it thinks is acceptable behavior:

Contept(s)	Rating
People	Good
Eating	Good
Eating, People	Bad
Eating, Food	Good
Talk	Good (I'm an excellent monkey-trainer!)
Talk, [to] People	Good
Talk, [to] Food	Bad
Talk, [to] People, [whilst] Eating	Bad (Very bad manners)
Talk, [to] Food, [in front of] People	Disaster!

This big mess would require quite some algebraic function to replicate! How would that even look like if we were to build that function in Mathematics? We could on the other hand use a lookup table to model this, but then any in-between state would be ambiguous – life is never black and white.

The astute amongst you might have noticed the clue within the title. Neural Networks are how the the living brain performs computation, and Artificial Neural Networks (ANNs) are our way of harnessing that technique and for computational purposes.

Similarly, our brains were given a training set - a set of rules which we had to learn similar to the above – there was never any mathematics involved.

Inside the Box

So what is an ANN? Well, what it looks like does depend on what you want it to do (indeed, not all parts of the brain look the same, so why can’t we cheat as well?). Generally speaking, an ANN contains neurons and synapses (just like a human brain) – each synapse linking two neurons together at either end. As with normal brain activity, a “charge” is passed from neuron to neuron via these synapses. The degree to which this transmission occurs is specified by the weight of the synapse, ie, a synapse with weight w=0.0 will transfer no charge, similarly if w=1.0 all of the charge is transmitted.

The human brain contains millions of such networks (or one big network if you think of it like that), but when using ANNs we can simplify to just a handful:

A small Artificial Neural Network

The network above is what is known as a Multi Layer Perceptron, and consists of at least 3 layers:

• An input layer which represents the inputs to the function
• An output layer which represents the outputs of the function
• One or more hidden layers which encodes the complexity

Using a suitably complex network, which has previously been exposed to appropriate training data (to be explored in Part 2), the following sequence takes place:

• We decide what the network represents. For the network shown above, we may wish to say that the 1st input means “Eat” and the 2nd means “People”. The output would mean “Good” or “Bad”
• We show our inputs to the input layer. This is in the form of a number between 0 and 1. For example, inputting a charge of  [1 , 0] would mean “Eat” “Not People”
• The charge from these neurons are propagated to the next layer, depending on the weight of each individual synapse. This is where the magic happens.
• The hidden neurons pass on their signals to the output layer, once again based on the weight of each connecting synapse.
• The signal reaches the output layer, where we can extract our result.

"Charged" neurons, shown glowing in yellow

The key thing to keep in mind here is that what you get out of the network is entirely dependent on the weights of the individual synapses, different combinations of which can produce entirely different outcomes. In effect, the knowledge the network stores IS the network itself. Complexity increases with the number of neurons and synapses, so the larger the network, the more patterns we can approximate.

Training

Because the weights of the synapses in an ANN are randomized at first, the network will most likely produce entirely the wrong result. To combat this, we train the network. When showing inputs to the network and observing an output, we decide how close this is to our desired output. For example, if we stimulate “Eat, People” and the network returns “Good”, then we tinker with the weights in the network ever so slightly in order to get closer to the desired outcome. Just like training a real gorilla, after many repetitions “Show, Observe, Adjust Behavior” the network learns the data.

And this relates to the real-world….how?

Simple, for example you can quite quickly build a function which outputs a list of films your customers might like to rent, based on ones they have already rented. All you have to do is get data in the form “She rented film X, then rented film Y”, continually show it to the network, and sit back and watch it learn (OK, it might not be that simple, but my point stands).

And talking of Netflix, we’ve arrived back at the start.

That’s where I will leave you for today. In Part 2, I will examine more closely how these networks operate, and the mathematics behind them. In Part 3, we will be programming a basic Multilayer Perceptron in Groovy. Part 4 will finally discuss some alternatives to MLPs and their uses.

Build new business, Protect existing revenue

It’s a simple mantra, fairly straightforward and generally good advice.

The issue arises when these two aims are diametricly opposed. Take Microsoft for example. They risk taking business away from their existing “offline” products such as Office, Windows and Visual Studio with cloud-based alternatives. The decision they have to make is clear, but implementation is painful.

For a company like Google, the process is far simpler – they have no existing profit streams to subtract from by introducing Google Docs, Chrome OS etc. Perhaps this is why Google appear to have a far brighter future than Microsoft for the time being.