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

Archive for the ‘Development’ Category

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!



Java has an undo button?

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

YOW! 2011 Australia Review

YOW! 2011The YOW! 2011 Australian Developer Conference was held a couple of weeks ago in both Brisbane and Melbourne and I was able to attend with thanks to Dave Thomas and the organisers of the conference on my press credentials for InfoQ. I had the ability to record some podcasts for The Agile Revolution and Coding By Numbers as well as chat with most of the Agile related speakers. Here are some of my notes from the sessions I got the opportunity to sit in.

Dave Thomas kicked off proceedings with some Lady Java:

Keynote: Top 10 JVM Erroneous Zones

Cameron Purdy from Oracle presented this session. Whilst it is good to see management levels talking about and understanding the core business, I found this keynote rather average. The presentation is available here.

From YOW 2011
  • immutability – no concept in Java, introducing would be good for thread safety but would also improve garbage collection (stop the stop -the-world clauses)
  • primitive types – binding between interface and implementation, improving would simplify and fix auto-boxing and generics, would need to make sure code compiles the same way
  • interface vs implementation – they are all the same thing, a problem that we all inherit from the same parent
  • properties – very fixed contract currently, need to loosen this up
  • obvious intrinsic types – Decimal needs to follow IEEE standard 754-2008 (754r), need to upgrade to a 128- bit world
  • real runtime model – JVM must provide predictability, need more access at code level
  • constants – no constants for intrinsics or other similar types
  • alternate class file format – limited to 64KB in methods, hierarchies make no sense like inner and anonymous classes
  • tail recursion / tail call optimization – performance benefits like Scala

Continuous Design

Getting the opportunity to see Mary Poppendieck speak is always a pleasure, for this conference she delivered her talk on Continuous Design. As the program host for the Lean and Agile track, I also had the pleasure of introducing Mary. Her presentation is available here.

From YOW 2011
  • continuous delivery misses design and feedback – how do we know what to develop if we are thinking about continuous delivery, has created a need
  • continuous delivery uptake is increasing, takes about a year to get going
  • need to assemble a diverse team – frame, ideaton, experimentation then iterate
  • 3M – make a little, sell a little, learn a little (repeat) – the fastest through this loop is the winner – fastest can be four times faster
  • need good people (pay attention to hiring) and a whole team (need all the functions which can break the agile 7 +/- 2 model), measure success in customer satisfaction
  • start with customers – Amazon (working backwards – write a press release, write FAQ, describe customer experience, write user manual)
  • disruptive design – companies like GE are starting to design products for different markets like China and India rather than USA and Europe – resulted in different design , thinking, price point
  • need to decide when it is time for people to see it – it’s hard to refactor books, hardware and first impressions but you need to take a chance and find out that you are wrong – a balance trade-off
  • minimum viable product – biggest waste is building the wrong thing followed by complexity – build it and measure the response (learn)
  • implement a show me more button and forward to to an under construction page and measure the clicks
  • Eric Ries – The Lean Startup 
  • avoid vanity metrics, need actionable metrics, use innovation accounting – start with a hypothesis, build MVP, target initiatives at improving a growth metric in your hypothesis, measure done as adding value
  • use A/B tests to change your conversion rate
  • test early – don’t waste your time arguing
  • cohort metrics – operate on data, as people run into my product how do they behave
  • feature toggles – switch features on/off on demand, wrap entrance to feature with toggle code, control via configuration file – customers love it
  • canary releasing – take a small amount of users and give them a new version, need to be able to tell a good change from a bad change very fast – monitor key thresholds and roll back fast if required – make sure when something goes wrong it never goes wrong again
  • Apple – ” it’s not about money” – understand customer problem and the revenue will turn up
  • Google – “it’s best to do one thing really, really well” – stay focussed
  • Amazon – “think long term” – you don’t want make a lot of money off your best customers, some things don’t always make financial sense
  • 3M – “hire good people and leave them get on with it”

I also had a great half hour chat with Mary on the second day of the conference where we talked in-depth about continuous design as well as size of the product team. She believes the key is to enable the complete development cycle and discover good engineering products. We should stop using software words, including Agile, and start using system level engineering. As for the team size debate, we should use system engineering and break our teams into appropriate sub-components.

60 Years of Innovative and Agile Work Practices

Nigel Dalton led this entertaining and informative trip down memory lane, and as the program host for the Lean and Agile track I also had the pleasure of introducing him. The presentation is available here.

  • people who pay your wages don’t know your stuff, this is a heavy duty approach that has been used for the last 100 years
  • 1930’s Cabinet War Room – as close to an agile room design as you can get, war is a fairly big project!, agile does scale (WWII), lucky it did or this presentation would have been in German!, military and politicians were in the same room, no battle plan survives contact with the enemy
  • 1940’s Lockheed Martin – trademarked skunk works – built a team and in 143 days built the XP-80, built skunk works rules
  • 1950’s U2 and SR71 – if you do good engineering, you will be amazed how long it lasts
  • 1960’s moon race – iteratively learning through doing, working rockets are the primary measure of focus
  • 1970’s Luna Tractor – Russians were striving for a different question, what is on the moon?, different question and cost a lot less money, Apollo 13 is the greatest example of an agile project, ask the right question…
  • 1980’s cold war fears – madness of strategic parity, Russians learnt a space shuttle program cost a lot of money after duplicating it, took the USA 30 years to learn it

I also had the opportunity to talk more in-depth with Nigel Dalton after his presentation for The Agile Revolution podcast with Renee Troughton.

Product Engineering

Mike Lee presented this session, in a sombrero, and his slides are available here.

From YOW 2011
  • underwear gnome algorithm, product engineering is step 2
  • product engineering is overarching, top down and empathetic
  • think about what you are going to do before you do it…
  • million dollar idea – ideas don’t matter and are usually terrible, originality does not matter, it is quality
  • ideas – it’s like a blank but with blank…
  • consider your customers – start at the end by making a commercial (30 – 90 seconds on the problem you are going to solve and how you are going to solve it)
  • your best product tester is your arch nemesis
  • in user interface – it is much more important to be consistent than correct
  • real artists ship – plan, design, ship on time!
  • don’t ship the rough draft
  • fear social debt much or more than technical debt – you can fix technical debt (you can but you won’t!)
  • shipping a product is like giving birth to a kid – there is a heck of a lot more work to come
  • endeavor to kill your own, you are never done, when people are raving about the first one, you are already finishing the second, you want an army of evangelists
  • Appsterdam – the most important thing we have is the community
  • the hook is the difference to a defining product, but need to keep being innovative

Better Testing With Less Work: QuickCheck Testing in Practice

John Hughes delivered this interesting session around Quick Test. The slides are available here.

From YOW 2011

Keynote: Escape From the Ivory Tower: The Haskell Journey From 1990 to 2011

The keynote kicked off with a tribute to some of our founders who we lost in the last year, including Dennis Ritchie:

Simon Peyton-Jones, the inventor of Haskell, delivered this entertaining keynote, his slides are available here.

From YOW 2011

Keynote: Temporally Quaquaversal Virtual Nanomachine Programming In Multiple Topologically Connected Quantum-Relativistic Parallel Timespaces…Made Easy!

With an award for the best title for a keynote ever, Damian Conway kicked off day 2 with this entertaining session.

From YOW 2011
  •  change your velocity, rotate your space-time deep
  • rod logic

Problem-Solving and Decision-Making in Software Development

Linda Rising pronounced this as the “weird talk”, her slides are available here.

From YOW 2011
  • meetings – no thinking
  • no scientific experiments that show agile is any better
  • we need sleep – but average time is dropping, naps are good too…
  • we are hardwired to look at the horizon, so lift your eyes and look around and blink
  • lying down improves your cognitive performance
  • research from University of Queensland – the longer you sit the sooner you will die
  • the startling ideas come at a time when you are doing nothing
  • eat before you’re hungry, drink before you’re thirsty – when the brain is lacking energy, the default is to say no
  • we are hardwired to be close to nature – we do better with natural light and real plants around us, take 5 minutes outside in a natural environment
  • explain the problem to your dog or a stuffed toy
  • in meetings, when at an impasse, get each person to explain each others version of the problem
  • fearless change experiments – test the waters, reflect, small success, step by step

I also had the opportunity to sit in on a very interesting interview with Linda Rising on the Coding By Numbers podcast with Craig Aspinall and Steve Dalton.

Domain-Driven Design for RESTful Systems

Jim Webber delivered this entertaining session, perhaps the most entertaining part was when he tried to explain a cassette tape to a young audience member (I remember loading Commodore 64 games off tape…). His slides are available here.

From YOW 2011
  • embrace HTTP as an application protocol
  • hypermedia helps us to explain to humans what to do next, can also use for computer to computer

Feedback Makes Everything Better: Understanding the Software Engineering Process

Bjorn Freeman-Benson presented this session, his slides are available here.

From YOW 2011
  • problem with Agile is we release and it vanishes with customers – The Progress Principle, The Lean Startup and Continuous Delivery are good books that solve this problem
  • continuous deployment – eliminate the fear around doing deployment
  • tests – a version of feedback, need confidence
  • automated deployment strategy – need to be repeatable using tools, need to be able to do quickly
  • need architecture that can handle inconsistencies in the system at any one time – different versions of API’s, etc. in the system at the one time
  • feature toggles – need on the technical and business side, toggles for beta users, power users, need to be able to work on one code stream all the time for it to work
  • traffic – need traffic for this to be successful, especially to get useful metrics
  • monitoring and feedback – what characteristics are being used, monitoring and qa are the same thing (see Steven Yegge’s rant on big SOA)
  • Apollo program was basically Agile and continuous deployment in the 1960’s – 61 launches until they landed on the moon – only way they made progress was because they were monitoring everything
  • record all the values all the time
  • pay attention to long term metrics, not just instantaneous
  • should use the word anomoly more (not bug) – use feedback to understand and fix our anomalies

Other Stuff

Joshua Kerievsky gave two talks at the conference that I unfortunately did not get to see live (Lean Startup and The Limited Red Society), but I did get the opportunity to speak to him in-depth with Renee Troughton for the Agile Revolution podcast.

Renee and I also did a wrap-up podcast.

I have also published a news article for InfoQ where I asked all of the Agile speakers at the conference what the Agile community needs to embrace in 2012.

Channel 9 were at the conference and recorded a number of video interviews with speakers that are well worth viewing. Peter Sellars has also written a comprehensive wrap-up of the day 1 talks.

YOW! Nights: Extracting Gold from Legacy Code

YOW! 2011Last month, Dave Thomas came to Brisbane for YOW! Nights to deliver his always insightful and entertaining presentation entitled “Mature Legacy Seeking Sexy New Technology for Fun and Profit: Extracting Gold from Legacy Code”. It’s been a pleasure to work with Dave on the last couple of Agile Australia conferences and I always try to make sure I catch his presentations when he is in town.

The following are my notes from the session:

  • a common complaint is that my boss does not let me do anything neat – legacy is a challenge
  • go where there is a big need rather than wherever everybody is – solve a problem that is important to them in a clever way
  • legacy code is code that has no tests
  • only if you have a product that matters you will have legacy – you can make bloatware even in new systems
  • legacy – the big ball of mud – OO is one of the biggest creators of technical debt
  • developers are the source of legacy debt – the developer solution is we can always rewrite it in my language – most rewrites fail
  • outsourcing often works short term – but you lose your business knowledge and you realise your requirements stink
  • vendor solution – start with a technology you don’t need
  • agile solution – just refactor it, there are no tools or practices that can fix millions of lines of code, it will take forever
  • need to figure out what the legacy is about – get the metaphor and a picture – write stories and put them on a wall, invest in getting the legacy programmers to sit down and talk about it
  • most companies are living on their legacy – new products are not paying the way
  • pair legacy and non-legacy developers to tackle the problem
  • use modern IDE, use modern SCM, new continuous build infrastructure is cheap, need fewer developers if your whole world is in memory
  • when everybody is using agile, how can it be the best practice – it is the only practice
  • prove your way through the old systems – there are very few greenfield projects
  • do TDD using live transaction roll back
  • automate from the data definition not screen scrape
  • people only do innovation when they are screwed – agile is predictability and quality not productivity
  • rewrite the contracts so that vendors can only install if they have automated acceptance tests – acceptance tests are the only way of putting two distinct processes together
  • big resource contracts should be split because the quality of resources are usually spilt in half – give it to local resources who have the talent
  • an agile coach is “an unemployed Smalltalk programmer”
  • think outside of the box – use spreadsheets to load data to the cloud
  • simple innovation in a difficult problem gets you a lot of respect – don’t ask your boss if you should write some Prolog to solve a problem
  • look where the customers are spending money – it is usually in legacy
  • lots of great opportunities to make a difference to hold your nose with the legacy smell – find where the biggest bang for buck is quickly – need to do it in months
  • KLOCs kill – more code to maintain
  • prove new ideas and do a little bit at a time

Sydney Go Inaugural Meetup January 2011

Google GoI got along to the “Googleplex” when I was in Sydney the other week, and with Steve Dalton checked out the inaugural Go Meetup. I have spent very little time looking at Go, so was interested to get some background into what it is all about.

Andrew Gerrand gave (part) of a talk on Practical Go Programming (I say part because it turned out to be a discussion with the slides rather than the talk). The slides are available here, but the talk is available as a recording from OSDC 2010.

Steve Dalton also interviewed Andrew Gerrand on the Coding By Numbers podcast earlier in the day, which is well worth a listen.

YOW! 2010 Australia Day 2 Review

YOW! 2010Day 2 of the YOW! Australia software development conference in Brisbane, the following are my notes from the sessions that I attended.

Keynote: Exploring NoSQL

Erik Meijer delivered this keynote, which essentially proved that relational databases and NoSQL are mathematical opposites. The slides are available here.

  • “NoSQL took away the relational model and gave nothing back” – Benjamin Black
  • SQL is complicated and not very efficient
  • principle of compositionality
  • SQL and NoSql are opposites mathematically

Leveraging Internet Technologies to Build a New Breed of Software Development Tools

Martin Nally from IBM delivered this talk on development tools and RDF, his slides are available here.

  • 78% of people cite delivery pressure as to why they don’t use ALM
  • vendors believe their tool is the centre of the universe – if that is the case you need to know the universe
  • AD/Cycle tried a central repository model in 1990 – did not work, but most vendors still trying to this
  • currently we try to use the integrated model
  • third option is to use the world wide web and linked data (Tim Berners Lee) – give everything an URI, use HTTP URI so people can look them up, provide useful information on lookup (RDF), include links to other URIs – this is just REST!
  • “tools are just a prison for data”
  • we still build tools like we built applications in the 50’s – need all the data
  • RDF – universal data representation for the web, SPARQL is the RDF query language – XML looks awful for RDF, Ntuples is much easier
  • – community around linked data for tools
  • focus on the integration scenarios because you will never get two customers to agree on the specifics of a test tool
  • friends don’t let friends represent data in XML
  • URLs should last forever – use virtual names, don’t tie to machines and don’t put meaning into URLs because it will change

iPhone & Android: From Concept to Delivery

Nathan de Vries spoke about iPhone iOS development and Daniel Bradby spoke about Android development, the slides are available here.

  • Australia has had abnormal adoption of the iPhone
  • design is a very important part of the platform
  • Apple publishes Human Interface Guidelines
  • aesthetic integrity – don’t want design to get in the way, match aesthetics to the type of application
  • direct manipulation – feel like you are interacting with the objects on the screen
  • metaphor – mapping design back to real life
  • consistent – apple provides a base framework – navigation, view, tab bar controller
  • start raw with ideas on big bits of paper, constraints of device means you need to be very iterative
  • when designing screens remember the different screen resolutions between the iPhone 3GS (480 x 320), iPhone 4 (960 x 640) and iPad (1024 x 768)
  • use vectors when designing images so that they scale down nicely
  • use the simulator but do not under estimate the value of testing on the device
  • testing tools not built into the culture but are gaining prominence (GHUnit and Cedar)
  • suggest that you always develop with the latest SDK for the latest devices and patches
  • use iOS Beta Builder to test with up to 100 users on real devices
  • use analytics to get real usage of your applications, 80% of apps are use once and 95% are abandoned after one month
  • track reviews but don’t take them to heart
  • Android is developed by the Open Handset Alliance, which includes a large number of developers, telcos and manufacturers, of which Google is just one
  • Dalvik is the Java virtual machine that runs on Android handsets
  • The Android IDE is built on top of Eclipse

The Emergence of UX in an Agile World

Victor Rodrigues and Xerxes Battiwalla from Cochlear spoke about combining agile and UX, their slides are available here.

  • agile came from internal IT projects, but UX came from consumer commercial products
  • experience needs to be designed
  • many user experiences are broken
  • a great resource is 20 Things I Learned About Browsers and the Web
  • start with a backlog
  • with UX you need to look at the entire system
  • decided that UX and development went separate ways and proceeded in two different stream
  • incrementally develop in a series of internal drops
  • 3 stages of UX evolution – idea storming (consider all options and dismiss them), prototyping (let designers choose their tools) and user testing (ease of use, makes sense, sketchy UI)
  • develop the UI after interaction has been defined, so start by developing the plumbing
  • designers and developers should use their own tools but talk a common language (markup)
  • MVVM – model – view – view model

Management 2.0: Leadership Models for an Information Age

Richard Durnal from delivered this session, the slides are available here.

  • – leaders vs managers
  • How I Learned to Let My Workers Lead – Ralph Stayer from Johnsonville Sausage in the Harvard Business Review
  • PARC(T) model – from The Modern Firm by John Roberts – People, Architecture, Routines, Culture and Technology
  • code wars
  • point kaizen (optimize points in the process)
  • flow kaizen (optimize the entire flow)
  • theory of constraints – keep working on the one problem that is causing you the most pain
  • systems management.theory helps bridge the gap from agile
  • kaizen vs kaikaku – kaizen only gets you so far because you see a slide, sometimes you need to introduce massive change
  • you can inspire people but they need to bring their own motivation
  • transforming REA – great people, cross functional teams, visual controls, agile and lean concepts, engineering practices, DevOps and hearts and minds
  • build a compelling vision (where do we want to go and follow)
  • decentralize responsibility and let go of control (people aren’t grasping in the way we expected, developers don’t grasp the business, take time to go out on sales calls, barriers they think are there are not really there)
  • work on the culture and the system
  • build a great environment (productivity gain has been huge)
  • look for trouble makers and throw them into teams with no trouble (wisdom of the crowd)
  • take risks, learn and move on

Row Together, Row in the Right Direction, Row Faster: Improving alignment and throughput in software development

Jason Yip delivered this talk, the slides are available here.

  • the best programmers are 10 times  better than average which is 10 times  better than worse
  • set the best performers as the standard (not the second worst performer) , teams only as strong as weakest link
  • need explicit time for performance and practice
  • lower threshold for incidents, raise threshold for incident response (fix the problem)

Forty Years of Fun with Computers

Dan Ingalls took us on a 40 year journey of his life in computing including Smalltalk 76 and 80, SqueakVM and Lively Kernel.

YOW! 2010 Australia Day 1 Review

YOW! 2010The YOW! 2010 Australia software development conference was held in Melbourne and Brisbane a few weeks ago. With a huge thanks to my good friend Nicholas Muldoon from the GreenHopper team at Atlassian, I had the privilege of attending the Brisbane conference. The following are my notes and thoughts from day one of the conference.


Extreme Java Productivity: Enterprise Applications in Just Minutes

Ben Alex from VMWare SpringSource gave this presentation on Spring Roo. This talk was one of the a-ha moments for me, as I really have not spent much time looking at Roo until now, and I was quite impressed with where they have taken this product. The slides are available here.

  • wanted to build productivity tool for Java developers
  • development time only, runtime stack is Spring
  • code generator active and passive
  • goal was not needing to read the manual
  • use ‘hint‘ and tab to help you setup the project basics
  • controller all‘ to get a web tier
  • Roo keeps a log and this can be replayed as a script
  • web tier is using Spring MVC – 35% of Java developers use Spring MVC, the rest still use Struts or a mix-and-match
  • can run Roo without an IDE, if you do you need to you can install the AspectJ plugin
  • minimal approach means Roo starts by creating a JAR and only creates a WAR when you need to create a web tier
  • easy to throw away Roo if no longer want it (can also re-add it if you wish)
  • database reverse engineer‘ to incrementally keep up with the database changes
  • can deploy to Google App Engine with one command, same with VMWare

Rails in the Large: How We’re Building (One of) the Largest Rails Apps in the World (for an Enterprise)

Neal Ford is always entertaining and in this talk he shared some learning from a large Rails development project. His slides are available here.

Neal started the talk with a visualisation of the activity on the project Subversion repository using Codeswarm. This is really cool but hard to explain, so here is a similar video of the Eclipse codebase. Look for the explosions, which are essentially big commits for releases.

  • the pursuit – inception phase / iteration 0 – 2 to 6 weeks
  • – asked Thoughtworks to build in .NET or Rails because existing developers were Java!
  • started with 2 developer pairs and added 2 developer pairs every week until they had 11 developer pairs, 8 BA’s and 6 QA’s
  • found that they needed more BA’s to pairs because of the ability to move through code quicker in Rails, traditionally about has about 3 pairs to 1 BA in Java
  • demonstration trumps discussion, don’t convince on technology too early
  • 3:1 ratio of test code to production code, typical for Rails
  • when living on a submarine, have fun!
  • run 8,996 unit tests in 4 seconds using unit-record
  • rule: unit tests don’t hit the database, mock and stub everything (under 1 minute) – fight the battle to keep tests fast and invent stuff if you need to
  • functional tests on the other hand can’t use stubs, run 3,964 tests in 248 seconds (under 5 minutes)
  • DeepTest – realised that tests were only using one core, so parallelised the tests – want to hear fans running on the machine!
  • Distributed DeepTest – use underutilised BAM’s (Bad Ass Machines) to run tests across the network
  • key to agile software development is feedback loops
  • Selenium Grid, used for User Acceptance Testing, problem is Selenium is really slow – took 8 hours sequentially, on grid was just over 2 hours
  • use continuous integration for lots of things that need automation (CruiseControl.rb)
  • VMWare Fusion to run dedicated applications locally
  • use green / blue infrastructure for deployment, means you test on real hardware and you have a rollback in parallel
  • project Mingle on the wall so there is a common canonical view
  • cc_board – clear view of status without needing to scroll – information radiator
  • jukebox.rb – plays a song when the build breaks, play a theme song upon successful checkin
  • pairing stations – installed Adium, no email because it is poison to developer productivity, use machine names and add the pair names to the status, laptops for personal machines
  • setup internal Jabber chat rooms
  • used API’s to update Mingle status on successful checkin
  • software is more about communication than technology
  • 100% pair programming
  • have fun, work does not have to suck!
  • automate everything – do something that is painful more often that will force you to automate
  • 1 click command to deploy to any development
  • canonical pairing stations using radmind (Linux and OSX) to keep all the machines in sync, some overhead but better than keeping 11 machines up-to-date by hand
  • for messaging started with message.rb as it was good enough, then moved to Starling when they needed it and understood what it would be used for
  • use external tests to check that external services still work
  • performance – use custom hand tuned SQL to do things like forcing indexes
  • upgrading is hard, don’t put it off for too long
  • you can solve anything with rock, paper, scissors and when you get really good you should check out

Integrated Tests Are A Scam

J. B. Rainsberger led this excellent talk on integrated tests. His blog posts (and the summary on InfoQ) on this subject go into a lot more detail. Finally his slides were impressive as they were drawn in real-time using an iPad.

  • slow – delays feedback which means more mistakes and more integrated tests
  • brittle
  • misleading
  • viral
  • corresponding collaboration and contract tests
  • the client always owns the interface
  • basic correctness – each layer talks to the next layer correctly

Testing Your Javascript

Corey Haines delivered this talk, which I blindly hoped would give an answer to the age-old question on how to deal with JavaScript (there was no sliver bullet though). His slides are available here.

  • has a bad name because it is just a scripting language
  • hard to test, no good tools
  • pain in testing means your design has problems – good design means it’s testable
  • tools – Jasmine, QUnit, JsUnit, JSpec,
  • BDD – not tool specific, concept specific, feature level tests driving example level isolation tests
  • 4 rules of simple design (Kent Beck) – tests pass (you need to be able to verify it works), no duplication (knowledge has only one representation), reveals intent (name your objects / variables well) and small
  • SOLID principles – next level above the four rules for good design
  • design guidelines – stratified design (layer cake design), find canonical representation of your data and get away from the DOM and wrap these with builders and behaviors

Domain Modeling with Processes – Adventures of an “object head” in Erlang land

Kresten Krab Thorup delivered this talk which walked through the challenges of developing Erjang (Erlang on the JVM). His slides are available here.

  • Java designed in the client server age – coordination happened in the database
  • Erlang is a perfect domain specific language for event driven programming
  • patterns to ensure system is reliable
  • build reliable systems in the presence of errors – isolation + concurrency
  • emulator + BIF (built in functions) + OTP framework
  • Kilim – coroutines and asynchronous processing for Java

Release It! Design and Deploy Production-Ready Software

Michael Nygard delivered this talk which detailed some of the content from his book Release It!

  • author of Release It! plus 3 other books including Beautiful Architecture, 97 Things Every Software Architecture Should Know and the Java Developers Reference
  • failure is everywhere and it costs a lot
  • five nines equates to 25 seconds downtime per month – planned and scheduled – impossible!
  • average availability is 88% (3.6 days) for JEE applications
  • since 2004, most security attacks are now at the application level not the operating system level
  • QA tests functional requirements, non-functional testing is timely and costly, we don’t test for longevity of under production load
  • observed availability and stability over time
  • increased interest in DevOpsdev2ops and devopscafe are excellent resources

Keynote: 50 in 50

Richard P. Gabriel and Guy Steele delivered this keynote that covered 50 language lessons in 5o words or less. Some of the highlights for me were Piet (a language that looks like abstract art, and changes in colour affect the program flow) and Shakespeare -(a language where the code resembles a Shakespeare play – they showed a great video of how this would look which was well done). I also relived programming of languages from my past and present including COBOL, JCL, BASIC, Python Ant and Java.

A copy of the keynote delivered at JAOO in 2008 is available online if you would like to watch or relive it.

Apple iPhone Management & Web Application Development Training

I got the opportunity today to attend Apple iPhone Management and Web Application Development training with a bunch of my colleagues direct from Apple Australia. I took a heap of notes which are available below:


  • supports new standards CalDAV and CardDAV
  • on iOS4,VPN functionality is now an app supplied from vendors (Juniper and Cisco), as opposed to only built into the operating system, meaning the software can be updated outside of OS revisions
  • security – device (pass-codes, device restrictions and policy endorsements), network (AES-256 hardware encryption, file level encryption, encrypted backups, remote and local wipes) and platform (mandatory application signing when submitted and checked when downloaded, sandboxed applications, encrypted keychain for passwords)


  • self service (configuration profiles to set mail, wi-fi, etc, distributed by USB or wi-fi, made in iPhone Configuration Utility) versus managed deployments
  • iPhone Configuration Utility – free for Mac and PC
  • identity identifier – important, certificate
  • can set whether configuration security can be removed or not
  • set passcode policies – length, autolock time, remember history, etc.
  • restrictions
  • set different wi-fi settings to appear on phone, VPN settings
  • web clips – bookmarks that are set on the phone
  • advanced – access point names (APN), Telstra has this for your own network inside the Telstra cloud
  • if you create a profile (eg com.demo.wifi) then a user could create a profile with the same name unless you sign it (in which case it would get bounced)
  • deploying profiles – USB, email (not recommended because they a user could use an use old profile stored in emails and you can’t tell if profile has been loaded), web, over the air
  • Secure Certificate Enrollment Protocol (SCEP) – a way to get the certificate and encrypted profile onto the phone when deploying over the air, Cisco technology originally used between routers, was the cludgy way before IOS4
  • Mobile Device Management – new in IOS4 – opt-in by the user and then MDM takes over, validates the phone by IMEI number, Apple Push Notification Server talks to the device, device talks to MDM via secure HTTPS channel
  • enrollment to confirm trusted user and device, certificates and remote configuration, additional restrictions such as disable data roaming
  • query the phone – model and device details, version, roaming status, applications installed on phone, settings for compliance, etc
  • provisioning profiles for enterprise applications to set usage and expiry dates
  • manage phone – install and remove settings, profiles, remotely clear (good for help desks), remote locking of device, remote wipe
  • third party solutions in this space from Sybase, MobileIron and Trust Digital amongst others, early days for most of these vendors and technologies
  • once enrolled you cannot un-enrol
  • no limit to number of profiles – can be all encompassing or can be small (ie just a wi-fi setting), can run at the same time, can’t disable a profile only remove it
  • not possible to do web filtering or block a third party application to be installed (except by disallowing access to iTunes or the App Store, with MDM you can see which apps are installed
  • blocking access to the application (eg camera) also blocks access to the API


  • activation, sync and backup and update software
  • activation gets carrier settings as well as registers the device, happens whenever a new SIM card is installed, possible to put iTunes into activation only mode (what they do at the Apple Store)

Application Installation

  • App Store, adhoc or enterprise
  • build application in Xcode on a Mac and get into the AppStore
  • adhoc and enterprise – provision, build, deploy and install (traditionally only via a cable)
  • for enterprise, now Wireless App Distribution, put application on a web server and install via the iPhone via your own application catalogue app
  • could also build an enterprise front end to the App Store, but you still need iTunes account and deal with purchases
  • can gift an application but is tedious


  • SDK – native apps written in Objective C (using XCode on a Mac)
  • web application – native user experience but runs from a web site using HTML5 and CSS, view optimized for Mobile Safari
  • hybrid applications – part SDK and part web
  • developer platform ($99 USD) and enterprise developer ($299 USD) – get Xcode plus emulators and resources
  • iPhone 51% of worldwide smartphone market, in Australia it is 93% of smartphone market
  • WebKit is basis of Safari, open sourced by Apple, also used by Chrome, Android, Symbian and RIM – used by almost all of the mobile browsers
  • web applications cannot access secure storage, camera or address book, receive push notifications orallow rapid updates, however, can do offline access and storage
  • web application distribution – host on a web server, create a landing page and populate with web applications
  • need web development skills, any IDE and most technologies (except Flash), iPhone and iPod Touch are identical to test on, can also use emulator
  • examples – and to replace intranet and be useful on an iPhone
  • same website, different view depending on the device
  • applications need to be finger friendly, a finger = 44px
  • applications need to be aware of bandwidth and latency – Edge -> 3G -> Wifi, turn on server side compression (GZip), break data into blocks (eg Wikipedia clicking Show to get more data), reduce number of files requested, JSON for requests, optimize image size for the device, use CSS3 for design
  • – 1130 files on web site versus 136 on mobile site and 43 seconds versus 8 seconds load time
  • give users a website escape to get to more functionality if they need it
  • at Apple spend much more time on design and less on code, debug and test
  • design for ease of use-  straightforward well designed workflow (such as settings screen)
  • viewport – 320 x 480 screen, but can display larger, set viewport via code
  • home screen icon – png file and link in code
  • full screen mode with no navigation bars, requires home screen icon and runs in own instance
  • set a splash screen – image and meta tag in the Head
  • SVG support – good for zooming and business intelligence
  • PDF support
  • URL schemes – to display maps, telephone integration, mail integration, SMS and custom – just put URL in the scheme format
  • geolocation API as part of 3.0 – get current coordinates, uses battery quite considerably so use on intervals
  • orientation – 90, 0, -90 or 180, you code if the application looks different in different modes
  • user agent strings for iPhone and iPad
  • Css3 for transforms, transitions and animations as well as design like rounded corners
  • see for coolness
  • touch events and gesture events eg. touchstart, touchmove and touchend
  • no applets, tooltips, hover, WML, file uploads and download, mouse over, print and modal dialogs, X509 certificates

Offline Data Storage

  • HTML5 implementation, not unique to iPhone
  • offline application cache – manifest file from website, requests data then keeps synchronized, means application can run offline
  • key-value storage – session or local storage, persist between closing the browser, cannot be encrypted in HTML5 but could store encrypted data in the value
  • local JavaScript database
  • full support for manipulating the DOM


  • Dashcode – good for simple applications or prototypes, from Apple, part of toolkit, Mac only
  • Sencha – rapid tool, takes care of underlying events, templates for controls and types, iPhone and iPad
  • jQTouch


  • push notifications
  • accessories only talk to SDK applications
  • enhanced location based applications, embedded Google maps
  • rich media

Hybrid Applications

  • full access to device, enhance without redeploy
  • iFrame in the native application

Atlassian Summit 2010 Day 2 Wrapup

Atlassian Summit 2010More than a few days late, but here are my notes from day 2 of Atlassian Summit in San Francisco:

General Session

Tim Buntel discussed how Atlassian develop their products and supporting the social side of development.

Atlassian Summit Day 2

  • concept – idea is defined, unstructured information and ideas from customers, use Confluence and a Specification Template, Balsamiq to do some UI prototyping, embed Office documents such as PowerPoint
  • plan – project manager gathers requirements and shepherds team, turn the requirements into epics and stories in GreenHopper, embed GreenHopper card view into the Confluence page, planning meeting use projector with GreenHopper, use markers and drag and drop into each sprint
  • build – developers take requirements and build, build a dashboard with open social gadgets to see relevant information, wallboards to visually see status, Bamboo for continuous builds, Fisheye to view and diff versions of code, new keyboard shortcuts in JIRA to get 15 minutes back every day, Crucible for peer code reviews
  • launch – marketing take the product and promote, generate release notes in JIRA, write documentation in Confluence

Michael Knighten then gave an overview of JIRA Studio:

  • issue key linking for associations between all of the tools
  • integration with Google Apps, attach documents being hosted will mean it is always most up-to-date version
  • workflow is the future – broken build will reopen issue, passed review will close issue, etc…
  • Bamboo is now included and uses Amazon EC2 for builds
  • release cycle to get closer to products

Andrew Rallings then spoke about Customer Support:

Atlassian Summit Day 2

  • measure support with customer surveys (get 40% response rate, 4 times industry average, 85% have positive experience), internal measurements
  • revamped knowledge base, Hercules Support Robot automatically responds to support tickets (friend him in Facebook)
  • series of blogs coming on how to do support coming soon and a Support Dashboard portlet

Mike Cannon-Brookes then spoke about 2011 and beyond:

Atlassian Summit Day 2

  • time zones in JIRA (JRA-9)
  • Atlassian Translations, community supported
  • distributed version control systems are growing fast, support for Git and Mercurial coming soon, Fisheye has helped people move from CVS to Subversion but will help people move to distributed version control (DVCS) as well, Fisheye to help visualize DVCS coming
  • leading edge customers using gadgets to assist managing distributed servers, Universal Application Links to connect applications together two-way
  • JIRAnywhere (current code name) JavaScript libraries to allow you to bring JIRA anywhere, such as creating and working with issues in Confluence, hover over links, etc…

Lightning Talks

A series of lightning talks on various topics were held across two different rooms. Here are some thoughts from the ones I attended:

Labels Magic (Anthony Pelosi)

  • finding information usually involves searching or scanning pages
  • as an author if you know some of the general information, you can bring this to the user, the inflexible approach is trying to put everything under a parent page, organise pages by business unit rather than time and use labels and the contentbylabel macro to track time sensitive information
  • add labels to pages and then display related pages with contentbymacro label, then create a combined product page
  • works on current space (self) or across spaces
  • label conventions require them to be typed correctly, there are automatic label suggestions however

Auditing Your Build and Release (Jim Severino)

  • define your process, diagram it, Atlassian think of theirs in loops (internal and continuous integration)
  • measure your process because you can’t change what you are not measuring (eg. checking out trunk, browsing version control)
  • canary builds or control builds that should always succeed to determine that infrastructure is working
  • get multiple build agents
  • control configuration with a system like Puppet (open source) and Open VZ to get kernel based virtualisation
  • build needs to be a first class part of the product, Atlassian embed build engineers into the teams
  • get people involved and talking about the build
  • test release artefacts after they are assembled

Information Radiator (Brendan Humphreys)

  • these can be low tech like lava lamps or build lights or a scrum story board
  • you want fast feedback and to change culture
  • big and understood at a glance, should be aesthetically pleasing
  • new JIRA wallboard – section of the wallboard cycles between burndown, relative performance and review blockers
  • built as a plugin that renders gadgets, just need a wallboard view mode
  • choose same bar colour to get gadgets to rotate
  • alpha now, works well in Firefox 3.6 currently

Getting Started with Plugin Development (Matt Ryall)

  • plugins don’t require Java, can use HTML, CSS and jQuery
  • don’t need a JAR file, can just upload an XML descriptor file if simple or you can use the Atlassian Plugin SDK
  • easily add a link to company intranet – create a web item plugin, put in an XML template, upload directly into Confluence
  • project status macro – user macro with a snippet of HTML, put into an XML template, upload
  • expose Cruise Control if it has JSON or a web service interface

Build Atlassian Plugins with Groovy (Paul King)

Atlassian Summit Day 2

  • overview of Groovy
  • scripting plugins to write Groovy inline
  • benefit in environments where you can’t restart JIRA / Confluence

Fedex Champions (Seb Rulz)

  • every 3 months, 40 pizzas and a few hundred beers
  • developers – breaks routine, improves morale, bragging rights
  • company – improves morale, fosters creativity, improves products
  • idea must relate to Atlassian, starts with a short idea statement (shipping order)
  • work overnight, at 3pm keyboards down and present, also present the failures

Mastering JIRA Workflows

Christina Bang spoke on lessons learnt in relation to JIRA workflows. She has a cheat sheet for JIRA workflows on the summit website.

Atlassian Summit Day 2

  • best feature of JIRA
  • Atlassian has workflows for budget approvals, kudos, audit trails for permanent records (such as approval to work on open source projects), any business process to replace a piece of paper
  • push process (hand off to someone else) versus pull process (unassigned, issues in waiting eg. support tasks)
  • issues always have a state and resolution (done or not done)
  • transitions are powerful, they have conditions (restrictions to move through the process), validators (fill out a field before proceeding), post functions (do things automatically)
  • schemes give you fine grained control, give you flexibility, be careful with how you name them
  • “Unresolved” == field has no value
  • default workflow was written with software development in mind, and that Atlassian is an open company (resolved == done and closed == shipped)
  • powerful + flexible = complex
  • what ever you do (K.I.S.S.) – the fewer steps, people will actually want to use the system
  • visualise your workflow, identify things to edit, plan transitions and test by walking a through issues through the workflow
  • JIRA workflow plugins – free (JIRA Suite Utilities for comparing number conditions, mandatory field transitions and copy field values, JIRA Toolkit for notifications and time since last comment and JIRA Misc Workflow Extensions for previous status and comment required) and commercial (JIRA Workflow Designer)
  • build your workflow in XML or build your own plugins
  • number in brackets after transition are useful when wanting to do different conditions
  • resolutions are global in JIRA, so you see them for every workflow (there is a JIRA property to hack and hide the resolutions)
  • visualise workflows – a couple of plugins, mostly commercial – Workflow Visualization Plugin was recommended (uses Graphviz)

JIRA Studio: Development In The Cloud

Kamal Nabijee from Razorfish spoke on building software in the cloud:

  • agile like process – concept, foundation, iterations, stabilization and launch
  • user stories are core to all of the deliverables – defines the customer experience and build everything around that story
  • 3 week iteratons, cut off to QA and code freeze in the third week

Shibab Hamid then spoke about how they do it at Atlassian when they integrated Google:

Atlassian Summit Day 2

  • JIRA Studio + Google Apps gives a complete development, collaboration and communication hosted solution
  • Google Talk embedded within JIRA Studio
  • concept was “tight integration and cool shit”, but the constraints were a distributed team and Google and hosting constraints

Kaizen with Greenhopper: Visualising Agile & Kanban Storywalls

The session I presented to a good crowd. The slides are available in a separate post.


Get every new post delivered to your Inbox.

Join 1,102 other followers

%d bloggers like this: