Tomb Raider - First Impressions

Just played through the first few hours of Tomb Raider and it is freaking awesome.

Since I have been saving up recently, I've been avoiding buying the many different games I want. Luckily Tomb Raider has dropped a load in price and I had just enough Amazon vouchers left over, yay! XD

When I first played this at the Eurogamer Expo (really looking forward to this year's, already got my ticket!), I didn't think all that much of it to be honest. Perhaps it was just having to play it on an Xbox :P

However having sat down and played with the game properly, I am really getting into it. For me it is modern day Assassin's Creed but with Lara Croft, what is there not to like?! The story is really gripping and the gameplay isn't half bad at all.

Camilla Luddington does a fantastic job on the voice acting for Lara, really letting you connect with all the emotion the character is going through. I'm shockingly impressed with all the versatile ways you can die and how they are all voiced perfectly! o.O

If like me you neither have the time or the patience to actually comb through games to find every single collectable, I found a good guide on locating the Treasure Maps for each area. Googling for an image of the area map with the Treasure Map highlighted is always handy as well!

So far so good, I'm not swept away by the combat or the platfoming yet but I do very much like levelling up! Looking forward to the May Bank Holidays to put in some real quality time with this little gem! XD

Developer Diary - Spring/Maven Bug of the Day

So I just stumbled into this trap whilst dealing with some legacy code, thought I share some of the gems I came across...

Did you know that Tomcat 6+ uses the "java.util.logging" logger and not the log4j logger? This means that if you ever want to make sense of messages like "SEVERE: Error listenerStart", you will need to stick a "logging.properties" file in your resources folder (see this article for more information). Thankfully Tomcat will then give you a better description on the actual underlying problem after this...

Which brought me onto the error message:
java.lang.NoClassDefFoundError: org/springframework/core/env/EnvironmentCapable

Having checked for a consistent spring version and doing much routing around, I realised the spring-core had not been explicitly declared as a dependency in the module I was looking at. Instead one of the other modules it depended on would load spring-core. This module just so happended to be the one I had just removed... Dx

Anywho, it is now declared as an explicit dependency in the pom.xml. I'm not sure if the lesson here is to be more strict with Maven or just to not use Maven all together :P

Skimmer's Guide - Presenting for Geeks

“A presentation is not about the content or about you - it's about the audience.”

WHAT IS THE ABOUT?

Dirk Haun brings to us the wonderful and concise "Presenting for Geeks". Reassuringly well presented, he takes us on a journey on how to convey a memorable message.

Firstly the importance of preparation is laid out, understanding your audience cannot be emphasised enough! We are given great tips on how to plan the presentation and ensure at the end of it people "know, understand and act on your message".

Following this we are given excellent advice on how to best utilise your slides and tips for presenting. Things to keep in mind include speaking naturally and always asking "So What?" on every slide. On top of this there is fantastic practical advice on finding images and on how to present code to an audience.

In the conclusion we are reminded to keep it simple and keep your audience in mind. Dirk reminds us that all of the advice is just that, advice and not strict rules. Utilise what you find useful and build your own presentation style.

WHAT STOOD OUT?

The Curse of Knowledge (p. 4)

A common pitfall that I and many others fall foul of is assuming the audience knows more than they do when explaining things. This short section explains how to deal with that nicely.

Avoiding Bullet Points (p. 14)

Fantastic advice which I 100% agree with, bullet points can be complete presentation killers!

Presenting Data (p. 23)

We are introduced to the "Five Principles of Presenting Data" and given brilliant advice on how to make a point with data.

IF YOU READ NOTHING ELSE...

SUCCESs Principles (p. 7)

A brilliant set of principles to keep in mind when putting together a presentation. (Simple, Unexpected, Credible, Concrete, Emotional, Stories).

London Code Dojo 22

Another outing to the London Code Dojo and I've come away with a treasure trove of lessons... now just to remember and apply them!

What Went Down

The dojo was a Checkout scenario, where we were given various fruits as input and we had to return the running total cost.

Whilst the problem was fairly straightforward, the challenge came in handling the shortened 15 minute pomodoro time limit and "requirements changes" in the middle of them!

Before the dojo, I set myself the goal of ensuring I did TDD like I meant it, which I had neglected in my previous dojo. This time I was pairing with Alexandra and I've posted my refactored take on what we did on GitHub (https://github.com/arkangelofkaos/CodeDojo22_Checkout). Once again I have used Java 8 in the code, luckily the collection manipulation leant itself nicely to Lambdas XD

My Impressions & Lessons Learnt

• Practise is tantamount to improvement, even after the last few dojos I can see that I am improving (long way to go still!)
• Advice on how to become a master at anything: "All you need to do is not give up!" (Keep practising!)
• Simple design is incredibly powerful but incredibly difficult to get right.
• In my experience, I still need to do a little design upfront, due to my lack of experience :P
• I still need to be more disciplined in refactoring after EVERY test pasts.
• Don't let technical debt build up, ever.
• Ensure tests are not fragile, remember tests are code too!
• Single Responsibility Principle is your friend, brilliant for creating "agile" code.
• As a goal, I want to do the Gilded Rose Kata which covers "Anti-If patterns"
• Pairing isn't supposed to make you twice as smart but half as stupid! :D
• Failing all else: KISS XD

London Code Dojo 21

My second outing to the London Code Dojo and I am kicking myself for leaving early :(

What Went Down

The dojo was a completely new exercise as expected but rather surprisingly it was a completely different set of rules! This time there was no super strict TDD rules but we were dealing with a slightly more complex problem.

The challenge was to generate 100,000 random numbers and sort them into order ourselves, with our own sorting algorithm! Everyone break out the panic sort ;) I had the pleasure of pairing with Rupert Wood and we just copied the wiki version of in memory quick sort >.<

Our goal was to make code as readable as possible and I think we managed that fairly well. The code is now up on GitHub (https://github.com/arkangelofkaos/CodeDojo21_RandomNumbers). See the initial commit for the raw version of what Rupert and I managed.

My Impressions & Lessons Learnt

• As mentioned, I had to leave early which really sucked as I missed the last part and the really important retrospective. Never again!
• I should prepare more and be more active in moving out of my comfort zone.
• Need to be stricter with the TDD!
• Since the dojo I spent a night refactoring the code and introducing Java 8 Lambdas to the equation :) This is also on the GitHub (https://github.com/arkangelofkaos/CodeDojo21_RandomNumbers).
• My goal now is to learn how to implement a super fast parallel array sort! XD

Behaviour Driven Development/Design

In my recent post about Trisha's design talk (http://arkangelofkaos.blogspot.co.uk/2013/03/ljc-event-trisha-gees-design-talk.html) I decided one of my goals was to sit down and properly learn what Behaviour Driven Development/Design was all about. Here are my thoughts...

Googling the subject immediately turns up the definitive article on the subject by Dan North: http://dannorth.net/introducing-bdd/ If you haven't read it yet, I highly recommend it as it is succinct and very easy to follow.

The basic idea of BDD is to align your code more to actual discrete pieces of business requirements (behaviour). This means that when you do TDD, your test must target missing behaviour in your system. Furthermore the tests, along with your classes and methods, should clearly describe their intent.

I've alway been a firm believer in writing "Plain English" code. With code completion in all modern IDEs, there is no excuse for obscuring your code with acronyms or unhelpful names. Making code read like normal sentences enables better communication between everyone.

I really like the tenents of BDD as it ideally keeps code cleaner. If you are having to use a really long sentence to explain what your code is doing, that is usually a warning sign to stop and think! However I am not enamoured with the idea of completely basing your development around BDD (using a tool like JBehave for instance). It seems a bit too prescriptive, although I admit I have not tried it in anger.

Overall, this has inspired me to think long and hard about my development process. Now really want to drill down and makes sure I am getting all the basics right!

LJC Book Club Give Away - Clojure Made Simple

Really excited to announce that the LJC Book Club is partnering with developer.press to give away 10 iBook copies of their latest book: Clojure Made Simple - Introduction to Clojure by John Stevenson.

Original post and details here:
http://ljcbookclub.wordpress.com/2013/04/06/clojure-made-simple-ibook-give-away/

Hopefully this will be a regular thing and we will have more books to give away on a regular basis. Not that they aren't really already, the price is $4 which was £2.66 when I last checked! Really great to see books becoming more accessible!

Functional Programming for the Object Orientated Programmer

Having finished our first book (The Well-Grounded Java Developer), the LJC Book Club has now started our new book: Functional Programming for the Object Orientated Programmer.

To keep things consistent, Ged and I will be keeping all the Skimmer's Guides on the LJC Blog from now on. I've drafted the first one and hopefully it will be available soon.

So far I have found the book a little slow, I'm dying to learn it all already! The functional style of coding combined with the old school command line style coding is bringing back strong memories of when I first started coding with Haskell xD

During the course of this book, we will be doing a load of exercises and I will be sharing all my code on GitHub (https://github.com/arkangelofkaos/fp-oo). Hopefully over the course of reading this book the quality of the code I produce will increase as well ;) However I am in dire need of a fully functioning IDE! My goal for next week is to try to get my old ultimate version of IntelliJ 11 fully set up and ready, I need my autocomplete and formatting back :P

In any case, so far the book is great aside from the slow start. I got so sucked into it that I've accidentally read ahead already. My immediate goals are to learn how to do recursion and pattern matching properly in Clojure, can't wait!