Skimmer's Guide - Don't Make Me Think (2nd Edition - Steve Krug)

WHAT STOOD OUT? 

Yes, it's a thin book (p. 6)

If something even LOOKS like it takes effort to use, it is less likely to be used. Steve has deliberately designed the book to be thin and thus appear to have "low opportunity cost". I find the meta beauty of this to be outstanding.

If something is hard to use, I just don't use it as much (p. 9) 

If a product is PAINFUL to use, I will actively seek to remove it from my life (glares at Windows and Internet Explorer).  

When you're creating a site, your job is to get rid of the question marks (p. 13) 

Don't make the user think! Bias your designs to making things obvious to the user. For instance, it should never be a question about whether something is clickable or not.

Conventions are useful, but boring to use! (p. 35) 

Web conventions are incredible useful, as they have well established patterns of usage. You don't have to train a user on how to use a navigation bar, it's standard now. On the other hand, conventions are terribly boring. It's hard to imagine your peers praising you for "great use of conventions".

The interesting piece of advice Steve offers out of this is: "Innovate when you know you have a better idea. Take advantage of conventions when you do not."

Omit needless words (p. 45)

A great quote from E. B. White, a rule in "The Elements of Style":

"Vigorous writing is concise. A sentence should contain no unnecessary words, a paragraph no unnecessary sentences, for the same reason that a drawing should have no unnecessary lines and a machine no unnecessary parts."

Get rid of "happy talk" on the site, anything that sounds like "blah blah blah". Same goes for instructions, make them unnecessary. Failing that, make them concise.

Some users search, some users browse (p. 56)

Steve likens searching a website with searching for an item in a store. Some shoppers will go direct to a person and ask for help, others will happily wonder around themselves. On websites, users may go direct to a search box or they may start browsing. It is important to cater for both styles.

Make sure that your search finds the right results and is effortless to use as well. Poor search capability leads to unsatisfied users, as per the story on page 69!

Show the navigation for all the potential levels before worrying about colours (p. 71)

Users usually end up spending as much time on lower-level pages as they do the top. This means that top-to-bottom navigation is important to work out from the beginning. To facilitate this, it's vital to have samples for each level of navigation. I liken this to seeing the forest through the trees, before you start arguing what colour the leaves should be :)

IF YOU READ NOTHING ELSE...

Don't make me think! (p. 11) 

Unsurprisingly the eponymous chapter of this book is a must read. Steve pleads with us that "if you have room in your head for only one usability rule, make this the one".

Someone who can barely work the Back button should look at your site and say "Oh, it's a ____".

This is further compounded by the later chapter where Steve implores us to make the choices on our website mindless.

We don't make optimal choices. We satisfice (p. 24)

A term coined by Herbert Simon, a portmanteau of satisfactory and sufficing. Steve points out that when we are faced with a problem, our normal behaviour is to pick the first reasonable solution for that problem. Users are unlikely to pour over your website to find the best option for what they want, they will most likely just pick "whatever looks good enough".

Keep the noise down to a dull roar (p. 38/39) 

A picture speaks volumes and the msnbc.com menu example is a great example of how simple black lines can ruin the user experience. When you're constantly fighting for the user's attention, you don't want a load of visual distractions to add unwanted noise.

Skimmer's Guide - Head First Design Patterns - Welcome To Design Patterns

“The best way to use patterns is to load your brain with them and then recognize places... where you can apply them. Instead of code reuse, with patterns you get experience reuse.”

FOREWORD

I'm reading Head First Design Patterns along with a few others in the LJC Book Club. As we read, I'll produce a series of Skimmer's Guide posts for each significant section of the book. The previous section, on the Introduction, is here. If you are interested, please join the discussion on our Google+ community.

WHAT IS THE ABOUT? 

Continuing from the introduction, we now take a deep dive into the world of design patterns. Emphasis is on the ethos that "someone had already solved your problems" and how we can reuse the experience of others. Design patterns are our way of standing on the shoulders of giants!

Keeping with the Head First method, there are many lessons and even more ways to make the knowledge stick inside your brain. We may only cover the Strategy Pattern and general design concepts but you can rest assured you will remember all of it!

WHAT STOOD OUT? 

Exercise - Coding Ducks! (Strategy Pattern - p.18)

This simple exercise gives us our first opportunity to get our hands dirty :) It is a very straightforward problem and does an excellent job of teaching you the Strategy Pattern. I've pushed my work to Github: https://github.com/arkangelofkaos/head1st_designpatterns_duck

Exercise - Design Puzzle (p.25)

Make sure you have mastered the basics by trying your hand at organising the entity/class diagram in this exercise. Everyone remembers their UML arrows, right? ;)

Exercise - Crossword (p.33)

I know what you are thinking, we are learning and ain't nobody got time for messing around with a crossword! Rather surprisingly however, it is very valuable for seeing if you have been paying attention. Doing it exercises a different part of the brain and in the very least helped me notice I missed a page! Nevertheless it is incredibly frustrating if you're bad at crosswords!

IF YOU READ NOTHING ELSE... 

Shared Vocabularly (p.26)

Communicating is one of the greatest challenges facing developers and learning to succintly transfer thoughts from your head to another person's is invaluable. Part of this is using the right language, which in our case is the language of Design Patterns. Learning all of this enables us to communicate faster as well as code faster!

Object Oriented Principles (p.30)

At the very heart of everything we are trying to do, there must be a firm foundation of solid object orientated principles. Design patterns work in tandem with these tenants, you must learn the practice and understand the wisdom behind it. All of this is reassuringly woven into the theme of the book: from subtly highlighting how "Inheritance is evil" to explicit recommendations (program to an interface!)

CONCLUSION

If you have little to no experience with the Strategy pattern, this chapter is a fantastic way for you to master the art of encapsulating varying behaviour. Even for those with some experience on the topic, the exercises both amuse and tax you, helping to reinforce our knowledge :)

Skimmer's Guide - Head First Design Patterns - Introduction

“Our goal was to make the book weigh less than the person reading it... Our focus is on the core patterns that matter...”

FOREWORD

I've recently started reading this book along with a few others in the LJC Book Club. As we read the book, I will be producing a series of Skimmer's Guide posts for each significant section of the book. Introduction to Design Patterns, the next section, is here. If you are interested, please join the discussion on our Google+ community. 

WHAT IS THE ABOUT? 

We start our reading of Head First Design Patterns with a gentle and enlightening introduction to the Head First world. Their approach is really intriguing and it is refreshing how much they are vested in helping the reader learn. Everything is to the point and we are immediately told who this book is and isn't for. Our goal in reading this book is stately clearly: learning that design patters are all about reusing experience and creating flexible code.

Despite the daunting size of this book (it is very heavy), the writing style and format makes it very easy and enjoyable to read. If you have experience with Head First books in the past, the introduction could be skipped although I highly recommend giving it a quick skim in the least.

WHAT STOOD OUT? 

Taster - Table of contents

Surprisingly enough, the novel table of contents work really well as a taster for things to come. Much like the rest of the book, the entertaining writing style brings the book to life :)

IF YOU READ NOTHING ELSE... 

Tricking your brain into retaining knowledge

One of the very first concepts covered in the book, this is the art of learning how to best learn. Absolute must read as the techniques covered are applicable to learning in all walks fo life.

CONCLUSION

Beginning to read this book has been a wonderful foray into the Head First world and has whetted my appetite for more. Looking forward to sinking my teeth into the world of design patterns in the next part :D

Skimmer's Guide - Functional Programming for Java Developers

“Multithread programming requiring synchronised access to shared mutable state is the assembly language of concurrency.”

WHAT IS THE ABOUT? 

Dean Wapler brings to us "Functional Programming for Java Developers". Although two years old now, the book touches on concepts that are still highly relevant both today and upon the introduction of Lambdas to Java.

We begin with why functional programming is so important and look at actual techniques we can utilise. Immediately after we are encouraged to apply our learning in handy and thought provoking exercises. This format is followed in each of the following chapters and really helps to reinforce learning!

How we model our data and operate with it is the next focus, introducing the "functional power tools" that are filter, map and fold. Along with the following section on functional concurrency, these two form an incredible bounty of invaluable information.

Recapping on everything we have learnt, we look at how to improve our object orientated programming and where to go from here.

WHAT STOOD OUT? 

Declarative vs Imperative Programming (p. 7) 

Highlighting the key difference between functional and object-orientated programming using a well thought out factorial example.

The Actor Model (p. 41) 

Fantastic coverage of this concurrency tool which is short and sharp, very useful for beginners.

IIF YOU READ NOTHING ELSE... 

Why Functional Programming? (p. 1 - 5) 
Concise chapter on why Functional Programming actually matters.

Combinator Functions: The Collections Power Tools (p. 29) 
A brilliant section on tools that are crucial in any functional language: filter, map and fold. Covers both what these tools do and learning more through actually implementing them for a custom List data structure.

CONCLUSION 

Whilst this book is a great introduction to the basics, it lacks any great depth. Published in 2011, the available functional programming tools of the time (such as GS Collections and Google Guava) are surprisingly absent.

In my view, what is lacking in depth is made up for by having such a broad coverage in only 72 pages. This book forms a good bridge for those starting with functional programming to take toward exploring specific topics/tools in greater depth.

Skimmer's Guide - Behaviour Driven Development with JavaScript

“BDD has many different aspects. Which of them are important depends on your perspective.”

WHAT IS THE ABOUT? 

Marco Emrich brings us a mature and enlightening insight into Behaviour Driven Development with JavaScript. Absolutely rammed full of excellent information, the book is nevertheless extremely well paced and reads very easily.

Beginning in earnest with a quick refresher on JavaScript, we are soon introduced to Jasmine, our JavaScript BDD weapon of choice ;) The underlying mechanics of BDD are explored (i.e. Red-Green-Refactor) before we are shown novel ways of generating data for our tests.

Particular attention is then spent on advising us how to organise/write our tests to maximise readability/maintainability. Following this we dive into Outside-In Development and how we can use it to flush out uncertainty. Use cases of the various types of 'test doubles' are covered, extensively so for mocks.

We finish by addressing the difficult question of "what is BDD?", bringing together everything we learnt into a formal methodology. The most important aspects are brought into focus and pointed in the direction of possible next steps into the BDD world.

WHAT STOOD OUT? 

JavaScript refresher (p. 7) 

Covering modern and functional aspects of JavaScript, this introductory chapter is incredible helpful for anyone rusty with JavaScript. Anyone experienced in JavaScript should probably simply skim/skip this though. 

Specs should be readable (p. 27) 

Great coverage of the DAMP/DRY principles here and throughout the chapter. Sound advice with warnings every developer should heed! 

Organising by feature or by fixture (p. 35) 

Interesting techniques for keeping tests cohesive and making them read naturally, through intelligent organisation and custom code tools. 

Using test doubles (p. 53) & Advantages and disadvantages of mocks (p. 61) 

Fantastic coverage on how and when to use dummy, stub and mock objects, including views on the pros and cons of mocking. 

Vocabulary (p. 61) 

A resonating account of the pitfalls of TDD for beginners and how an improved vocabulary better enables proper testing. 

IF YOU READ NOTHING ELSE... 

Baby Steps (p. 23) 
Wonderful teaching on the importance of having a "tight feedback loop". Emphasis it placed on how the longer it takes to find a problem, the harder it is to solve it. Taking baby steps when changing code will let you go faster! 

Triangulation (p. 42) 
A wonderful technique for "faking it until you make it", forcing you to test all the relevant paths through your code. 

Gerkin language (p. 66) & Goals and benefits (p. 67) 
Covers the fabled "Given Then When" syntax of BDD and how it isn't necessarily central to BDD.

CONCLUSION 

At less than £2.60 ($3.99) this book is insanely good value and I would highly recommend it to anyone starting to learn BDD, even if they have limited JS experience. Despite centring around JavaScript, the core concepts of BDD are covered magnificently and can be applied to any language. 

Highly accessible and easy to reference, this book definitely warrants inclusion on any developer's digital bookshelf.

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).

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!

Skimmer's Guide - "Chapter 10: Clojure: Safer Programming" of "Well-Grounded Java Developer"

Foreword

Recently I set-up the LJC Book Club (blog here) with Ged Byrne and the first book we chose was "The Well-Grounded Java Developer" by Benjamin Evan and Martijn Verburg.

As a part of the reading schedule, Ged and I are hoping to produce a weekly "Skimmer's Guide". 

This is my first such attempt and hopefully there will be many more to come!




“..Lisp is an acronym for Lots of Irritating Silly Parentheses...”

What did we read about?

Week 6 has brought us to the Clojure chapter which focuses on introducing the functional language to Java developers. The topics range from your simple 'Hello World' program all the way to Clojure style concurrency being used to steal all the money from Ben's account!

What stood out?

Arithmetic, equality and other operators (p. 287)

Simple explanation of the Clojure mathematical operators and introduces variadic functions. In-short using a variable number of function parameters - e.g. (+ 1 2 3) // returns 6

Schwartzian transform (p. 290)

Great example which allows you to learn how to read Clojure "inside-out" and really get to grips with core concepts of functional programming.

Multi-thread ATM (starting p. 308)

Fantastic example of whole concise Clojure can be over Java, as well as explaining how to do concurrency in Clojure.

If you read nothing else this week...

Getting started with the REPL (p. 281)

Get started hacking on the "Clojure console" and learn about mutable/immuntable state in Clojure.

Interoperating between Clojure and Java (p. 299)

Learn how to call Java from the "Clojure console" and get under the covers of Clojure on the JVM.