Online presence of Craig Smith — Agile Coach & IT Professional in Australia

Author Archive

2013 WordPress Review

The stats helper monkeys prepared a 2013 annual report for this blog.

Here’s an excerpt:

The concert hall at the Sydney Opera House holds 2,700 people. This blog was viewed about 11,000 times in 2013. If it were a concert at Sydney Opera House, it would take about 4 sold-out performances for that many people to see it.

Click here to see the complete report.

Agile Encore 2013: Visual Management: Leading With What You Can See

AgileEncore2013My presentation from the Agile Encore 2013 conference called “Visual Management: Leading With What You Can See” is available on Slideshare.

Renee Troughton was unfortunately unable to join me to present this reprise of the talk we presented together at Agile Australia 2013.

Using task boards or story walls is a key Agile practice, but are you making the most of it? Visual Management is more than just putting cards on a wall, it is a growing style of management that focuses on managing work only by what you can see rather than reports or paper being shuffled around. Visual Management allows you to understand the constraints in the system, mitigate risks before they become issues, report on progress from the micro to the macro. Visual Management can also be used to demonstrate to customers and clients where the work they care about is at. This presentation is all about taking the management of your work to the next stage of transparency. Discover:

* How to identify when your story wall isn’t telling you everything and how to adjust it
* What the three different types of story walls are and which one is more suitable to certain circumstances
* Different ways to visualise your product backlogWhy queue columns and limiting work in progress is so important regardless of whether you are using Scrum or Kanban
* How symbols and tokens can be used to give more information
* What else can you use other than story walls to visualise information
* How to ingrain Visual Management into both the team and management structures of your organisation
* Visualising Your Quality, Testing and Team
* What is systemic flow mapping and why is it important

Unfortunately the talk was interrupted about three-quarters of the way through by a rogue video conference call into the auditorium. My attempt to try and answer questions why people were trying to fix the problem were interrupted by audio coming through the call. We soldiered on – but it interrupted the flow.

And here are some feedback from the feedback forms – much appreciated!

  • Lots of ideas
  • Very informative with real world examples
  • Delivered as per advertised. Was relevant and interesting to listen to. Some great take outs
  • More relevant to where we are as an organisation
  • Big wall
  • Most applicable as I am a newbie
  • Kept the audience engaged from start to finish
  • The task based techniques most relevant
  • Gave more understanding of how to do better Agile



Meals Per Hour

A great video demonstrating how Lean principles can be applied to everyday life, such as disaster relief or non-profits.

And kudos to Toyota for sharing their knowledge for charity.

Agile 2013: 7 Deadly Sins of Agile Software Test Automation

Agile2013_Speaker_bannerMy presentation from the Agile 2013 conference called “ 7 Deadly Sins of Agile Software Test Automation” is available on Slideshare.

Adrian Smith was unfortunately unable to join me to present this extended version of the talk that he has presented previously at Agile Australia and Fusion.

Automated software testing is a key enabler for teams wanting to build high quality software that can be progressively enhanced and continuously released. To ensure development practices are sustainable, automated testing must be treated as a first-class citizen and not all approaches are created equal. Some approaches can accumulate technical debt, cause duplication of effort and even team dysfunctions.

The seven deadly sins of automated software testing are a set of common anti-patterns that have been found to erode the value of automated testing resulting in long term maintenance issues and ultimately affecting the ability of development teams to respond to change and continuously deliver.

Taking the classic seven sins (Gluttony, Sloth, Lust, Envy, Rage, Pride, Greed) as they might be applied to test automation we will discuss how to identify each automated sin and more importantly provide guidance on recommended solutions and how to avoid them in the first place.

A full house for the talk, some really positive feedback and heaps of questions following the talk, so thanks to everyone who attended!

Yehuda Katz on Ember.js (Ninefold Event Brisbane)

ninefoldYehuda Katz is a well respected figure in the Ruby and JS communities, so it was no surprise that it was packed house that turned up to see him last night in Brisbane. And whilst the room was hot, there was a lack of chairs and Yehuda himself was getting frustrated with the feedback and cutoff in the house audio system, it was a great night organised by Nigel Rausch on behalf of the guys at Ninefold.

Here were a couple of items I picked up on his talk on Ember.js:

  • like Ruby and Rails, Ember.js is not optimised for computer science but for developer happiness
  • ambitious app – optimised for building entire applications, long lived applications (like Gmail, lasts on the screen for a very long time) need a sophisticated architecture
  • MVC is not quite enough – model (all sessions), controller (just this session), view (what is currently visible)
  • use HTML and CSS to layout application, is the lingua franca of the web
  • HTML needs more dynamic features – {{ for data binding, # block form in Ember
  • URLs are important – good applications have good URL support – like Twitter or Rdio – primary way that people share information in Twitter and email for example – is the UI of the web, we should use them more universally and use them everywhere

Yehuda then gave a demo. Having not used Ember.js before I was impressed by how easy it was to build URLs and interactivity. I certainly will give it a closer look at some stage.

  • future of the web – take a look at the google project – Polymer
  • evergreen browsers – Chrome started this, once you download the browser that is permission enough to download new versions of the browsers ; Safari has not adopted this and will probably become the next IE6!
  • some good resources include embercasts and Ember 101

There was also an interesting kick off presentation by Toby Hede about some of the cool stuff Ninefold are doing, if for nothing else the animations were amusing!

Agile Australia 2013 Review

Agile Australia 2013Agile Australia 2013 was recently held in Sydney with over 850 attendees and 3 days. Between running a pre-conference workshop, recording interviews for InfoQ, presenting a session and being a MC for a number of sessions, it was a fairly busy time but I did get to sit in on a couple of sessions.

I was once again one of the conference advisors, although this year we introduced the role of Stream Chairs and Reviewers who took the bulk of the review of the 240 plus submissions and, I think, went some way to making the whole selection process more transparent and community driven.

Pre-Conference Workshop – Introduction to Agile

There were a number of pre-conference workshops running on the day before the conference, and on behalf of Software Education I ran an Introduction to Agile workshop for a small but engaged group of people new to Agile. According to the course overview:

This course provides an independent one-day introduction and overview of Agile Software Development. We look at the underlying philosophy and motivation for this trend in software development and examine the core values, principles, practices and techniques that fall under the broad “Agile” umbrella. Independent of any single brand, this course looks at the key factors that are needed to apply Agile effectively and provides an experiential introduction to working this way.

InfoQ Interviews

InfoQ was a media sponsor for Agile Australia this year, and being the Australian based Agile Editor for InfoQ, I undertook the organisation iof the recording of sessions and interviews. I recorded a number of interviews throughout day 1 of the conference and I look forward to seeing them available on InfoQ in the coming months.

Visual Management: Leading With What You Can See

The session I presented with Renee Troughton had a great turnout and plenty of questions afterwards.  The slides are available in a separate post.

In relation to the sessions that I attended, here are my notes.

Keynote: The Lean Mindset

Mary Poppendieck delivered the opening keynote, her slides are available here.

  • going beyond software
  • Thinking Fast and Slow by Daniel Kahneman – two types of thinking – system 1 (fast, instinctive and emotional) and system 2 (slower, more deliberative and logical)
  • need to see the waves and learn how to surf them, rather than trying to control the waves
  • cognitive biases – confirmation biases (align with people with same thinking), anchoring (hang on first piece of information), loss aversion (careful not to lose what we already have rather than gain)
  • dealing with options – teenage decision making (either/or or whether or not), widen the frame (what about both or none of the above), multiple options, patterns
  • speed and quality are compatible, you learn that you can’t go fast without high quality
  • Continuous Delivery by Jez Humble and Dave Farley has become the bible, supersedes iterations and Kanban because it’s too fast, whole feedback loop from customers to the development team
  • Ericsson – the past is not good enough for the future, stop projects because they are big batches
  • accept uncertainty and learn how to live with it – range estimates over point estimates and manage flow
  • managing complexity – probe, observe and adjust; dealing with it – flow, obstacle, adjust
  • wisdom of the crowd, widen the perspective, zoom in/it, look at base rates (probability of success in your market and what makes you different)
  • why do companies fail – they focus too much on success, take what they have and make it better, forget to look at the big picture and see what the world is doing – Garmin and Magellan lost 70% of their market overnight due to Google Maps on the iPhone
  • Carol Dweck on the Growth Mindset – fixed mindset versus growth mindset
  • perfection paradox – learn to fail and learn to prevent rather than striving for perfection, resilience is learning to fail
  • flow depends on your engagement – deeply engaged, no distractions, time evaporates – otherwise you drift between anxiety and boredom depending on your expertise

Keynote: Managing for Serendipity

I was quite looking forward to seeing Dave Snowden and hoping his talk would cement in my mind the Cynefin Framework. His slides are available here.

  • it is better to have a partial view of the whole, than a complete view of the parts
  • theory deals better with uncertainity than practice
  • exaptation (taking something that exists and enable it to a different purpose, usually two unrelated things)
  • agile manifesto swung too much towards customers and away from how we can educate them
  • you absorb complexity, don’t delude yourself into thinking you can eliminate it
  • outliers are where opportunity and threat manifest themselves first - most research and search eliminate them
  • only way you can understand a complex system is via experimentation.
  • evidence supports competing hypotheses
  • Dave’s Harvard Business Review article

  • you want to cycle between complicated and complex, stuff that goes to simple usually becomes complacent and dies
  • cynics care about your organisation – they are the only ones making noise
  • meetings should not be used to resolve problems – you get dominant players – you want to to do 5-7 parallel safe to fail experiments
  • interventions should be coherent, safe to fail, finely grained, tangible – tackle problems oblique (plant different ideas, like managing a teenager), naive (anthropology experts in the Holiday inn), a few high risk high return options
  • process is what you need to change people (sorry mainfesto), naive if you think you an change one person at a time
  • complex domain action form – if it doesn’t fit in top 4 boxes it is not safe to fail
  • micro narratives are what we want (stories developed in workshops are not the same as the discussions around the water cooler)

Keynote: Beyond Budgeting

The highlight of the conference for me was to meet and hear from Bjarte Bogsnes, as I have long been a fan of his Beyond Budgeting work. His slides are available here.

  • the purpose is not to get rid of budgets, need to change traditional management and the budgeting mindset to make organisations more agile
  • written into The Statoil Book, but has not reached all corners of the organisation
  • transparency is a great social control mechanism and good for learning
  • management recipes – someone has done all the thinking for you, beyond budgeting is not that
  • Beyond Budgeting principles
  • we budget for targets, focussing and resource allocation – inefficient and in one number – separate the numbers and be event driven not calendar driven
  • change the mindset from do I have budget to is this really necessary and how much value it is creating
  • Statoil abolished annual budgets, but they still have project budgets but can get money at any time (the bank is always open)
  • need good information to make decisions – current status as well as capacity
  • use a burn rate rather than a budget, with some variance
  • use a unit cost, keep exploring as well as you stay within a unit cost
  • bottom line – good costs create value, eliminate the bad ones
  • express cost in words rather than dollars as strategic actions and objectives
  • need to start trusting our people
  • “the way we deliver is as important as what we deliver”
  • objective > measure > actions > goals
  • KPIs – perfects KPIs do not exist, make them ambitions to action
  • dynamic forecasting – don’t put everybody into the same limited time buckets – some people need small time frames, some people need years
  • apply pressure to the KPIs – were they ambitious, did you stretch versus low balling, were there outside influences
  • mechanical link and no judgement between KPIs and performance bonus is dangerous

The Guessing Game: Alternatives to Agile Estimation

Neil Killick has become the voice of the #noestimates discussion in Australia (whether he likes it or not). His slides are available here.

  • estimation – what am I going to get and when
  • estimates set an expectation level
  • in 12 moths time if estimates come true – either by good guessing or by adjusting for over runs
  • we have known unknowns – can’t predict them and can’t ignore them
  • use real constraints – what can we build for this money, budgets create a real deadline and bring out creativity
  • create mini constraints and iterate and learn, come up with a mini solution for what we can do, small iterations to keep options open and diversify our risk
  • need an a-team that can build solutions continuously
  • iterative pricing – allows the customer to cut the cord early, possible even with traditional contracts
  • present customers with expectations of of what they are going to get and when – flexible options
  • slice things to the same size, avoid story points, count cards – price per feature
  • story points will be gamed – people will make the burn chart look good

In Conversation with Patrick Eltridge

I was the MC for this session that was a coffee table conversation between Beverley Head and Patrick Eltridge, the CIO of Telstra. When I introduced this session, I made the comment that it was interesting to see how Telstra was progressing on their Agile journey and Patrick was at the conference for his third year now; in the first year we didn’t really believe they would be able to make an Agile transformation and in the second year we weren’t sure how much was fact and fiction. In 2013, they are certainly making their presence felt with over 70 people at the conference, a title sponsorship and a number of sessions being presented.

I did not get to hear all of the session, but hear are some snippets I picked up

  • IT strategy needs to be driven by the corporate strategy, then creating an environment that can change and people being the best they can be
  • huge “opportunity” when he joined Telstra
  • celebrate successes as much as possible – stiffens the spine for the naysayers
  • reverse mentoring – mentor older staff with younger ones to pass on new thinking and ideas, both sides learn
  • nations can benefit if agile leadership is successful
  • simplified scorecards and KPIs – single number of financial performance (EBIT), engagements with stakeholders, employee engagement plus project outcomes
  • Scaled Agile Framework and weighted first has allowed Telstra to have acute business control and adapt as required

This discussion also spawned some news articles around graduates mentoring CEO’s and five day interviews.



Java has an undo button?

Agile Australia 2013: Visual Management: Leading With What You Can See

Agile Australia 2013 Speaker ButtonMy presentation with Renee Troughton from the Agile Australia 2013 conference called “Visual Management: Leading With What You Can See” is available on Slideshare.

Using task boards or story walls is a key Agile practice, but are you making the most of it? Visual Management is more than just putting cards on a wall, it is a growing style of management that focuses on managing work only by what you can see rather than reports or paper being shuffled around. Visual Management allows you to understand the constraints in the system, mitigate risks before they become issues, report on progress from the micro to the macro. Visual Management can also be used to demonstrate to customers and clients where the work they care about is at. This presentation is all about taking the management of your work to the next stage of transparency. Discover:

* How to identify when your story wall isn’t telling you everything and how to adjust it
* What the three different types of story walls are and which one is more suitable to certain circumstances
* Different ways to visualise your product backlogWhy queue columns and limiting work in progress is so important regardless of whether you are using Scrum or Kanban
* How symbols and tokens can be used to give more information
* What else can you use other than story walls to visualise information
* How to ingrain Visual Management into both the team and management structures of your organisation
* Visualising Your Quality, Testing and Team
* What is systemic flow mapping and why is it important

Lynne Cazaly did an awesome visualisation of the talk!

We had some great feedback from people after the talk as well as via Twitter.

Renee also has a (slightly earler) version of the slidedeck online via her Slideshare, with one slide change and one omission…

Brisbane Agile Meetup: Scrum Masters: The Full-Time Role Conundrum

MeetupMy presentation from the Brisbane Agile Meetup in May 2013 called “Scrum Masters: The Full Time Role Conundrum” is available on Slideshare.

A replay of the talk delivered by Craig Smith at the recent Scrum Australia gathering in Sydney

The Scrum Guide defines the Scrum Team as being made up of three primary roles: Product Owner, Development Team and Scrum Master. The role of the Scrum Master is often misunderstood, particularly by management, so often questions start to get asked such as “can I share the Scrum Master across teams”, “can the Scrum Master do Project Management” and “can the role be rotated”?

In this talk we will take a look at some of the misconceptions around the Scrum Master role, discuss how it fits into the organisational structure and tackle the age-old question of whether the Scrum Master is a full time role. We will also look at an improvement plan template to help Scrum Masters improve in their role.

Brisbane Agile

Here are some comments from Meetup:

  • Great presentation. Definitely good value (Gustavo)
  • Very good presentation. Good value. (Wilfred Brimblecombe)
  • Interesting subject, nice presso, Craig good value. Great presso, good job Craig. Also brill venue – good old Suncorp. (Derek Walsh)
  • Great presentation, thanks. (Chris Fortuin)
  • Impressive presentation, invaluable advice. (Carlos Augusto de Oliveira)
  • Craig did a great job putting together and presenting his scrum-master-view-of-the-world presso… (Juan)

An Introduction to Clojure

ClojureI had the pleasure this week to sit in on a 2 day Introduction to Clojure workshop being run by one of Clojure’s core developers, Stuart Sierra. YOW! and Relevance, Inc. are running these workshops on the east coast of Australia throughout May 2013 and for someone still very new to functional concepts it was a great introduction to functional programming as well as the Clojure language itself.

The key to a workshop like this is the slides with the code examples and the labs to practice the learnings, Nonetheless, here are my notes from the course on some of the concepts that I picked up.

Introduction to Clojure

  • designed to fix shared state concurrency, designed to run on the host platform
  • ClojureScript designed to target devices that cannot run a full JVM like mobile platforms, browsers, etc..
  • most of this course is applicable to ClojureScript, just the interrops to the host environment are different
  • BigInt (trailing N), BigDecimal (trailing M)
  • Strings in double quotes, characters in “”, reg ex are started with a #
  • literal true and false, nil is the same as Java null
  • symbols are words in your program you want to reference from somewhere else, always resolve to something else
  • keywords are a special type of symbol, start with a colon :, fixed labels that have no meaning, used for names of fields often, close to enum in Java
  • REPL – read, eval, print, loop – from LISP, all the steps are separate which is different to interactive terminal
  • every expression starts with an expression, everything returns an expression which is why you get nil when doing a println
  • REPL *1 will get you most recently used expression
  • print and println will give you human readable, prn and pr will give you the machine readable output
  • list are written in parens, usually represent function calls
  • vectors usually reflect collections, in []
  • maps are key value collections, in {}
  • set starts with a hash and curly brackets
  • commas are whitespace in Clojure
  • first is the function position, usually starts wuth a function or an expression that returns a function
  • quote (‘) is syntactic sugar for quote, prevents evaluation, common issue when starting Clojure when dealing with lists
  • doc – built in documentation
  • Leiningen – built on Maven, hides complexity but gives you its goodness
  • project.clj – dependency file


  • functions are first class and values, most of the core code are pure functions (no side effects)
  • defn defines a named function (defn greet [name] <body>) is a definition called greet, passes a name and runs some functions, then call as (greet )
  • can have multiple aritys, [] is no arguments, others are the named arguments, useful way to provide defaults
  • & in argument vector says next arguments gets all the remaining arguments in a list (0 or more)
  • fn is anonymous function with no name (fn [parms] body), to call it you can stick it at the head of a list, use this if you need to do something one time
  • shorter synatx is #(), and use % sign for the arguments, syntactic convenience
  • usually invoke a function by putting it at the head of the list
  • apply takes a function and list or collection or arguments, same as invoking a function on those arguments
  • let used for local variables, uilt into the compiler, takes a pair set of bindings (symbol and an evaluated expression) and then a body of any number of expressions
  • fn creates a closure, locals are stored and kept with the function
  • invoking Java – instantiation (Class. argument)
  • read Clojure inside out, read the inner most function and then read out

Expressions and Loops

  • in Clojure everything is an expression, always return a value even if that is nil, multiple expressions always return the last value
  • flow controls always return a value as well
  • logical false is false or nil, everything else is true, similar to the semantics in Ruby and Python
  • when is a macro – check and do a buch of things if evaluates true
  • cond – tree of if then else without lots of nesting, test – expression pair, stops when it hits the first true test, can end with an :else default by convention only
  • case – occasionally useful, like switch in Java, takes constants and returns value, if you don’t define a default you get an error, odd number of expressions, the last one is the default
  • dotimes – basic loop (dotimes [i 3]), only useful for side effects as it never returns a value
  • doseq – iterates over a collection, like for-each
  • for – not for looping, generates data, returns a sequence
  • recur – for recursion, rarely used, loop defines bindings which you recur
  • exceptions – don’t use them much in Clojure, no checked exceptions, try-catch-finally as per Java, throw to throw an exception
  • ex-info and ex-data that allows you to pass back a map
  • with-open – convenience wrapper, works with any method that needs to be closed


  • Clojure runtime is a singleton within the JVM
  • namespaces allow you thave the same name mean different things in different places
  • ns – use macro at the top of the source file to create a namespace, :require keyword to load the dependent libraries
  • implicit mapping between namespaces and files, dots into slashes and hypens into underscores
  • ns :use : only is deprecated form of :require from 1.4 up
  • ns :import for importing Java classes, every namespace imports java.lang
  • in-ns to change namespaces
  • equivalent macros for when using the REPL instead of a file
  • a bunch of functions for returning namespace information, but would rarely use these
  • private vars are just a metdata symbol, use ^:private, not truly private or hidden


  • a class or a struct becomes a map in Clojure
  • clojure.set – mathematical set operations
  • vectors are functions, can call using the indices
  • mostly use vectors, lists are useful when you want to work at the head of the list as it is more efficient, like simulating a stack
  • seq – returns a sequential view of something, like an iterator but it is not an iterator, can get first or rest
  • range – infinite lazy sequence of integers
  • into – puts a sequence into a collection
  • take / drop – take the first n in the sequence, drop the first n in the sequence, also filter and remove
  • map – the essence of functional programming – calls a function on a sequence and returns a sequence, the functional equivalent of for/each
  • reduce – powerful, uses first element if not initiated
  • some – to return the first logical true in the sequence


  • concurrency – multiple things happening concurrently that are sharing the same state
  • deref – returns current state, shortcut is @<ref>
  • atom – basic container with mutable state, changes are atomic, synchronous
  • ref – coordinate and share identities, synchronous, must be iolated in a transaction, uses locking under the hood
  • ensure – ensure the state is the same when the transaction is completed
  • alter – change the value of a reference in a transaction, if another transaction tries to change it gets aborted
  • commute – same behaviour as alter but allows concurent updates in a transaction, use for counters, adding elements to a map, if you are not sure use alter
  • agent – asynchronous communication, atomic updates, ensure only one thing done at a time, every agent has its own queue
  • send – send an action (function) to an agent, execute in the order that you send them, can’t guarantee that other threads are not sending action, fixed size thread pool
  • send-off – variable size thread pool
  • vars – thread safe, global identity, alter-var-root to modify global state created by a def, by convention dynamic var is surrounded by * (called earmuffs)
  • swap! and reset!, convention to put a bang at the end of functions that have side effects or shouldn’t be put inside a transation
  • watches – experimental, takes 4 arguments – key, reference, old state and new state, you can then add-watch
  • future – background process, if you de-reference the future it will block (@<ref>)
  • promise – like a future but no running process, like a container, can wait for it to deliver that promise to another thread, can only be delivered once
  • realized? – to ask if a promise has been delivered


  • polymorphism – two types protocols and multi-methods
  • type – what is the type of class using class or type
  • maps do not have a notion of type, record allow you to give a type to a map, defrecord creates a record, by convention the name has a capital, records are maps so we can call all the map functions
  • record automatically creates the constructor function called -><function>, map-><function> takes a map
  •  when you create a record you are generating a Java class, useful when creating a lot of maps with the same structure or to implement protocols
  • protocol – like a Java interface, group of functions that do not provide an implementation, called based on the first argument, defprotocol to create the functions
  • convention _ is an argument I don’t care about
  • reify – creates anonymous types
  • extend-type and extend-protocol – allows you to create new interfaces to existing types, solves the monkey patching issue
  • multimethods – generic methods, much more flexible than protocols, uses defmulti and defmethod, an extensible switch


  • macro – pure functions – defmacro – code is input and output, define the symbols to reflect the code that we want, macroexpand-1 is used for testing and debugging to see what that macro does
  • syntax quote `
  • unquote ~ and unquote splicing ~@
  • most of the core language where not functions are macros, write macros for syntactic convenience

Clojure and the JVM

  • Clojure is tightly integrated to the JVM, is unlikely to be the bottleneck performance wise
  • arrays can use aset and aget to access, use Clojure Collections but maybe needed for interoperability, can use to-array and into-array
  • types and collections are all mapped over to Clojure
  • built in benchmarking in Clojure using time function, time a loop to get a better indication rather than just time on its own
  • by default everything is boxed in Clojure, but Clojure has limited support for long and double primitives
  • compile – pass your namespace, will give you ahead of time compile which gives a modest (30% – 40%) speed increase amongst other benefits, usually will us leinengen or another tool (lein compile)


  • ClojureScript is designed to deliver optimised JavaScript
  • two pieces – ClojureScrpt compiler written in Clojure on the JVM, compiles Clojure to JavaScript, then the Google Closure compiler optimises for space for performance
  • lein-cljsbuild makes ClojureScript tolerable
  • ClojureScript One but is superceded by Pedestal now
  • testing frameworks – Clojure.test, Midje testing framework written by Brian Marick and Simulant

Get every new post delivered to your Inbox.

Join 971 other followers

%d bloggers like this: