OSDC 2009 Day 3 Wrapup

/ Craig Smith / 4 Comments

Day 3 of the OSDC conference, I presented two sessions on Agile (with Paul King) and Data Migration, so preparations and organisation got in the way of attending and as many sessions as I would have liked. Here are my notes from the sessions I attended.

Keynote – Google Wave

Dhanji Prasanna presented the keynote, here are my notes from the session:

  • answer to question “what would email look like if it was invented today?”
  • not just about text, about structured content
  • gadgets – state is stored in the wave (eg. using maps)
  • can exchange waves across different wave servers using federation
  • keep data you own on your own wave server, put you collaboration on the public wave server
  • robot participants are first class participants
  • spelling robot corrects spelling in context, and runs server side (Spelly), Linky does similar for links
  • use open source tools like Guava libraries, Guice, WebDriver, GWT, OpenJDK
  • all of Wave will be open sourced, including the client
  • can play with the reference implementation right now

Experiences From Agile Projects Great & Small

The session I presented with Paul King had a good crowd in the main auditorium. The slides are available in a separate post.

Experiences from Agile Projects Great & Small

“Change Bad!” – Change in Database Schemas and Source Code

Andy Todd delivered this session, here are my notes:

  • “Data matures like wine, applications like fish”
  • What changes – tables, views, stored procedures
  • could put DDL in version control – not same as database object
  • could put database independent model in version control – representation only
  • database = DDL + data + implementation
  • could store complete DDL for each scheme version – lots of work for DBA
  • could store complete initial DDL & subsequent deltas
  • could store complete DDL for every version and subsequent deltas
  • don’t forget about reference data and schema (user) creation scripts and store in version control
  • even if scripts are in version control, you should still have a backup
  • secret to success is testing – should be like code and have unit tests and be automated
  • hard to rollback
  • every migration should maintain data integrity
  • pioneering work by Scott Ambler – Database Refactoring
  • high availability is a different kettle of fish – all of the above is invalid
  • need to think about how you version control your database structures, different to how you manage source code

Data Migration In An Agile Open Source World

The session I presented had a decent crowd. The slides are available in a separate post.

Lightning Talks

Open Source Game in 5 Minutes

local::lib::environment

  • working with multiple distinct libraries in Perl
  • integrates with CPAN, etc…
  • virtualenv in Python does the same type of thing
  • cloning this for Perl, available on github

Ext.Direct

  • no Perl implementation for ExtJS, so wrote Ext.Direct
  • similar ports for a lot of different languages

OSIA (Open Source Industry Association)

  • local industry association for open source
  • $50 to join
  • numbers used to give to government

bluehackers.org

  • for geeks dealing with depression

Locknote – Open Source in Government

Pia Waugh delivered this keynote, my notes are as follows:

OSDC 2009 - Day 3 - 40

OSDC 2009 Day 2 Wrapup

/ Craig Smith / 1 Comment

Day 2 of the OSDC conference, one talk delivered today with Paul King on Using Groovy for Testing. The following are my notes from the sessions that I attended.

Keynote: Simplicity

Marty Pauley delivered the keynote, my notes are as follows:

  • good code is easy to read, beautiful (aesthetically pleasing), useful
  • evil code is difficult to read, ugly, but it is still useful (otherwise you would have no code!) because unfortunately it is still in use
  • good code should be fast, concise, advanced, maintainable
  • “Simplicity is the ultimate sophistication” – Leonardo Da Vinci
  • comments are an indicator that you’re code is crap, documentation and comments are not the same (documentation is useful), ironic that some languages put documentation in comments (eg. JavaDoc)
  • always out your scripts in a module, makes it easy to read (the comment was made in relation to Perl) and makes it easier to test (one script that calls one module, that can then call other modules)
  • Google is good example of simple (as compared to Excite and Yahoo! at the time) – search engines started complicated and became simple
  • Example of simple first is that Americans used the Space Pen in space (highly engineered pen that would work on all surfaces and work in space), but when they asked the Russians what they used, it was a pencil
  • “Java was designed for stupid people! – was designed because it was deemed to hard to write code in C”
  • look outside your current toolset, we all have problems in common

How to get Rails Web Applications Accepted in Industry

Harley Mackenzie presented this talk, my notes are as follows:

  • why Ruby? – expressive language, object oriented as everything is an object in Ruby (lends itself to good, readable, maintainable code), dynamic allows to delviver scripts quickly and maintainable
  • hard to find Ruby people? – many recruiters do not understand the roles they are recruiting for, Chuck Jones (of Warner Brothers cartoon fame) looked for artists knowing he could train them to animate, the same goes for quality developers
  • open source – lower initial cost, source will never disappear as will always be around in some way, don’t emphasise the FREE but the FREEDOM, dynamic languages you always have the source (not compiled)
  • efficient – productivity important to industry
  • elegant – write easy, maintainable code
  • reliable – “testing to oblivion approach”, everything has tests, commercial environments do not value testing, all say it is a good idea but will not pay for it
  • expressive – easy to understand what the code is doing
  • why is Rails not adopted? – management are risk averse (don’t want to go outside the Microsoft norm), corporate IT motivated by fear and uncertainity (like to do things the way they are always done), loss of control (don’t understand and don’t like when you know about things they don’t), outsourced IT providers (only in it to make a buck so resistance to change)
  • solutions and adapt (know what you can change and what you can’t)
  • demonstrate – give them a VM (“take the puppy home for the weekend), find the champion
  • cloud solutions – if you can’t deal with anorganisation and their infrastructure, bypass it (use Amazon or similar)
  • draw the line – sometimes you have to walk away than comprimise (figure out where the line is), usually can deal with server operating system, web server and database but not the language it can be written in

Open Source Web Apps in Azure

Jorke Odolphi delivered this session, my notes are as follows:

  • software as a service (SaaS) – multi-tenant, pay as you go
  • platform as a service (PaaS) – applicationn frameworks, languages
  • infrastructure as a service (IaaS) – pay as you go, scale (like Amazon EC2, GoGrid)
  • Windows Azure is an operating system in the cloud, where you run applications, designed to scale
  • lots of servers sitting in shipping containers (2,000 servers per container, 7 hours to get up and running after delivered) with VM’s running Windows (called the Fabric)
  • components – web role (front end facing, static content, ASP.NET 3.5, WCF, Fast CGI applications such as Perl, http(s) inbound), worker role (like a Windows service), storage (blobs, tables and queues)
  • running PHP in Azure – Eclipse tooling available (WindowsAzure4E)
  • MySQL in Azure – run as a worker role (configure ports and storage)
  • Tomcat running in the Azzure Cloud (http://oss.cloudapp.net/)
  • No environment yet in Australia, but Singapore coming soon, pricing

Desktop Applications for Web Developers

Ben Balbo presented this session, my notes are as follows:

  • cloud issues – network outages, working offline, server outage, application failure affects everyone, access/ownership of data, dependence on third party to fix bugs
  • Google Desktop Gadgets, Adobe Air, Windows 7 – just HTML, all the information stored in the gadget or via a web service
  • Mozilla Raindrop – Mozilla’s reaction to Google Wave, pre-alpa, a local web service
  • WordPress + Google Gears
  • iPhone applications
  • XUL – XML User Interface language from Mozilla, load any interface around Firefox (use Firefox as a framework)

Using Groovy for Testing

Presentation I gave with Paul King, and was an interesting experience on how to break down a 3 hour presentation to a 30 minute talk (which we started about 20 minutes prior to the talk commencing)!

Business, Law, Open Source

Brendan Scott presented this talk and these are my notes from the session:

  • each decision you make limits your subsequent decisions
  • Starting a business has effect on how easy it be to sell down the track (setting up within a corporate vehicle) – selling of shares make this easy as the legal person transfers. Most businesses are setup where the owner owns all the assets and personally signs up to all the contracts such as phones where their name is on the contract (makes it hard to transfer later on)
  • stay away from partnership (and the use of the word partner)
  • Pov Ray had pre-open source licencing, wanted to sue someone who was bundling it and selling it – needed copyright ownership to sue but had to go and find all of the contributors first
  • code consents in case somebody takes code and uses it in breach – keep records of who, what, when
  • IP Ownership – once you have transferred rights, it is very difficult to recover these rights, you need to get legal advice early
  • dispute resolution – usually because people not speaking to each others, lawyer can help you identify issues, send the nasty letters, courts look favourably if you have tried to sort out the issue
  • negotiations – lawyers familiar with the lines of argument
  • legal arcana – knowing the legal secrets and finding holes in contracts, etc…
  • copyright – owned by employee unless agreed otherwise
  • don’t lie about your products and services (Part V 52 Trade Practices Act)
  • Part V, Dvision 2 Trade Practices Act – don’t exclude warranties, limit recourse to repair or replace, it is illegal to exclude warranties

Lightning Talks

An extended session of lightning talks. here are the notes:

Make my PHP 66 Times Faster

  • slow code read in a really big library everytime it is run
  • idea is to make a socket call and run off the server, loading only once

Something About Cars

  • entertaining comparison of programming languages to cars

The Coming Programming Language Crisis

  • entertaining look at new programming langauges, recruiting for the Australian LOLCODE Developers network! (see http://lolcode.com/)

OSDC – Open Source Developers Club

  • parent organisation for the conference
  • like meetings (found about every third session, people attend a session that is not their usual language)

Hosting Web Sites In The Cloud

  • created Grocery Choice, wanted something that had scale initially but assumed would not need it going forward
  • Amazon EC2 – virtual machine farm, upload your VM to the cloud (takes about 3 hours)
  • using commercial, licenced server so limited to CPU’s that coule be run
  • can move your instance onto a larger virtual machine
  • pay as you go, for what you use

Geography, Databases & Government

Netrek

Phoebe’s Netbook

  • Phoebe is 4, has an original eePC
  • the distribution is very easy for children
  • TuxPaint and other programs in Linux that are good for kids

GMT (Generic Mapping Tools)

  • set of command line tools
  • pscoast – will show a map, can then map cyclones as they move down the coast

Byte code optimisation using Promise

Open Source Licencing vs Microsoft

UpStarta.biz

  • starting a business with no money
  • do something disruptive – is a potential client trying to solve a problem that your product addresses
  • low-end disruption – easier way of doing something that already exists (eg. MySQL vs Oracle)
  • new-market disruption

Handy Python Functions

  • if building libraries, pleause use doc tags!

Katoomba

  • open source SMS gateway
  • written in Ruby
  • will be released shortly

Trosnoth

  • written in Python using pygame
  • open source, GPL
  • team based, strategy game

Google Wave Bots

  • Wikifiy
  • Piratify
  • Flippy

OSDC 2009 Day 1 Wrapup

/ Craig Smith / 2 Comments

OSDC 2009 Australia is being held in Brisbane this year at the Bardon Conference Centre, and I was lucky enough to get 3 speaking slots (2 shared with Paul King). Day 1 was full of interesting talks, my notes are summarised below.

Understanding Volunteers

Karen Pauley delivered the day one keynote. My notes as follows:

  • recommended book by Charles Handy (Understanding Organizations)
  • organisation for mutual support (eg. Tokyo Linux Users Group, Sydney Perl Mongers) – consist entirely of volunteers who have a shared interest, don’t like to be managed, but a group needs some management (it’s like herding cats), anybody can join
  • organisation to provide a service (eg. The Perl Foundation) – requires structure to handle queries, cannot just join if you want you, expectations of communication and responsiveness and regular releases
  • campaigning organisation (eg. Enlightened Perl Organisation) – camapigns aren’t managed they are led, usually fail when the organiser gets bored
  • motivations – in open source we like to reinvent things
  • fun should be self evident, we volunteer to enjoy ourselves
  • lack of respect can stop the fun, need to treat each other well, need to apologize (and not follow it with a but…)
  • anger – “I know you’re all volunteers but…”, feedback can offend volunteers, in many cases people don’t mean to offend, in some cultures you write directly, tone down the rage and pause before replying
  • learnings – want a creative learning environment, learning and using something new is fun
  • as per Maslow, one of our key needs is to belong
  • belong with people who think the same way
  • impressions – decide very quickly our perception of people (4 seconds) – in person we judge looks, on the internet we judge the way we type
  • our first impression of people on the internet could be an email, IRC or a twitter – we make judgements of people based on 140 characters
  • the online life is real, so be yourself
  • everybody has a voice, make your communities fun

Joopal and Drumla: Not Your Usual Mashup

Sam Moffatt presented this brief talk about Joomla! integrated into Drupal (Drumla)

Introducing Django – Calling All Web Developers with Deadlines

Akash Mehta delivered this talk, my notes are as follows:

  • Django is a web framework to build websites quickly
  • used by a lot of newspaper / news / media sites (see DjangoSites.org for a full list)
  • a Python framework – extremely powerful high level scripting language, do a lot with less code
  • a python web application framework – excels at data driven web applications
  • a python full-stack web application framework – if using Django you are using the full system, not portable, mature, been around 5+ years
  • batteries included – functionality you need comes out of the box
  • Django has good support for internationalisation
  • DRY -> DRY (OAE) – Don’t Repeat Yourself (Or Anybody Else)
  • views do not usually have URL’s mapped to them, custom URL mapping takes care of this
  • not a serious business framework (see djangopony!)
  • good documentation – starts with a comprehensive tutorial, documentation then splits into functioanlity / what you want to achieve, stored in Subversion, there is an online version of the book which is also published by APress and available on Safari
  • automatic administration – not a scaffolding, end-to-end solution for managing production data, lots of useful widgets
  • available applications – search (Haystack is the current favourite), blogs (plenty available on github), security and administration built-in
  • views take advantage of decorators in python, such as @login_required
  • templates – template inheritence and blocks
  • URL config – no automatic mapping, create your own URL’s, can use regular expressions, usually mapped to views

Perl6 Now

Scott Penrose delivered this talk, my notes are as follows. Talk will be made available online.

  • when is Perl 6 available – now, language specification
  • looks like Perl
  • biggest problem with Perl is when you have @array you need $array to access it
  • More information at http://rosettacode.org/wiki/Category:Perl_6 and http://github.com/perl6/perl6-examples
  • Pugs – not very active, but a good reference application, written in Haskell
  • SMOP / Mildew – library parsers
  • Sprixel / Elf – implementations
  • Rakudo – run time engine, implementation of Perl 6 that runs on Parrot
  • full version should be available next year
  • performance – slower, Parrot keeps changing, performance increasing month on month
  • CPAN – not currently available but coming
  • 42 modules available now via github, mainly web and database
  • IDE – Vim syntax highlighting and Padre
  • debug – Larry Wall – “why do you need a debugger, just print line”, no interactive debugger yet
  • fun langauage to write in – can write code shorter and faster, execute faster is coming

oFono – Open Source Telephony

Denis Kenzior delivered this talk on oFono, my notes are as follows:

  • many devices and modems to talk to – all talk vendor specific protocols
  • existing projects – FSO, only considering smartphones, assumed AT modems, API not well constructed, implemeted in Python and too slow, does not support multiple modems
  • existing projects – Qtopia, end of life, did not support D-Bus
  • learnt from these projects – GSM is hard, huge and boring, everything exposed in the API but very little used or available
  • GSM is hard – massive amount of specifications (call handling (in, waiting, multi-party) sevices such as call waiting and number exposure, SMS), vendor specifics (enhanced SMS, smart messaging, WAP), storage (number, calls, SIM)
  • GSM is really hard – backwards compatibility (most of the specification still around from 1G), every bit counts, bugs in all of the different vendor hardware that needs to be worked around
  • oFono targets all devices, target all distributions, minimal dependencies, modular, UI easy to customise / replace
  • don’t use SIM for contacts / SMS – limited to number of contacts / messages – simplified the design
  • device detection – udev, modemconf
  • plugins – read / write to SIM, send / process SMS, Call / SMS history, D-Bus interfaces such as carrier logos
  • atom – implement specific functionality eg. dial, hangup, merge, switch, invokes operation on an atom driver
  • currently supports – network registration, make and receive calls, SMS, cell broadcast, GPRS, all supplementary services
  • handful of modems and devices supported
  • Phonesim– simulates most AT modems, make / receive calls, SMS, MWI, cell broadcast, network registration, supplementary services – good for development simulation
  • API – consistent, minimal, easy
  • takes care of magic strings (MMI, those *xxx strings), read / write from SIM, service provider display (MVNO, files on the SIM)
  • oFono plugins for BlueZ – hands free & audio management
  • oFono plugins for ConnMan – 3G network management
  • oFono currently has no CDMA support
  • unique because can support mutiple devices at once

State of Play: PHP in 2009

Akash Mehta delivered this talk, my notes are as follows:

  • 1995 – PHP/FI, 2000 – PHP 4.0 (very successful), 2006 – PHP 5.1.2 , 2009 – PHP 5.1.3 (developed and released at same time PHP 6 being discussed, so many features back ported)
  • language extensions
  • 450 user groups, 1200 members in San Francisco group!, 100 in Brisbane active
  • Microsoft and Zend – awful on IIS, they are working on it apparently
  • used in dynamic applications, social networks (Facebook), business applications (FLOW3)
  • IDE’s – Eclipse – PDT, PHPEclipse, Zend, NetBeans PHP, JetBrains working on PHP editor (Web IDE)
  • SVN still dominant, github growing in popularity following in the footsteps of Rails
  • server – Apache losing ground, growing in popularity lighttpd and nginx
  • phpDocumentor for automatic documentation
  • Phing and Capistrano for build and deployment
  • Project Zero is PHP on JVM
  • Xdebug is popular for debugging, DBG is also reliable
  • CakePHP – Rails for PHP, Mozilla Addons was the big thing but recently dropped for Django
  • CodeIgniter – strong following, low barrier to entry
  • Symfony – popular, strong following, high barrier to entry, hard to use with existing code
  • Zend – full stack approach

Git Me Up

Nigel Rausch delivered this talk on Git, here are my notes:

  • adopted quickly in Rails community
  • distributed version control
  • centralised – CVS, SVN
  • distributed – Bazaar, Git, Mercurial
  • Git created by Linus Torvalds, developed for Linux kernel patch control as replacement for BitKeeper (was one patch every 6 seconds, now 6 patches per second), so needed to be fast
  • effcient in management of files – entire repository for Linux kernel is only 40% bigger than the kernel on its own
  • commit locally to your machine – have full copy of all history – can commit at anytime, can always look back at history
  • simple branching and easy merging
  • support multiple remote servers
  • SVN is simpler to use, single point of truth all the time, central control, until recently better tools
  • git init – creates a hidden directory .git, which has config and history, use to start a repo
  • git clone <repo> – clone an existing repo to start a new repo
  • git add <file> – add to repo
  • git commit -m “message” – commit to local repo
  • git has about 150 commands, plus all their options
  • git branch – master is there by default
  • git checkout – checkout a branch
  • git log – commit log history
  • git merge <branch> – merge two branches and create a new commit
  • git remote add origin <repo> – this happens automatically if you cloned
  • git push origin master – origin is server we are pushing to (by default called origin), master is branch
  • git pull origin master – fetch and merge from remote repository, pull is a fetch and merge, a fetch will just get and leave in a pseudo repo
  • Mac installs with GitK which is ugly. GitX is a better bet, TortoiseGit for Windows
  • git svn clone – will create a bi-directional git repo of your SVN repository, commit locally and push back to SVN, at a later poiint you can change your origin to a Git repo
  • rebase, or work on a branch and merge to master locally so you don’t have all of the little commits
  • initial high learning curve, supports commit often, gaining support, IDE support growing
  • binary files saved and compressed in repo

Lightning Talks

A bunch of 5 minutes lightning talks, here are the brief notes from the session:

LLVM

  • low level virtual machine
  • risk based assembly language with annotations
  • clang – convert C and C++ to LLVM
  • adopted by Apple

withgui

  • GUI programming in Python, wxPython is ugly, PyQt4 meh
  • idea – with gui.x (where x is column, frame) – clean
  • still things to do, code not yet released

Visualising Geo-Data

  • government 2.0 taskforce
  • big csv file about sighting of frogs in South Australia
  • frogspotter – every dot, different species, different colours, then a cluster library
  • the data aggregator – drill down on the data
  • frog census

Connectr Social Network

  • currently Twitter with 650 lines of Python, wish to take on Facebook!
  • current social networks have issues with privacy, incentives for hosts are wrong for users
  • no business model, not hosted on server, runs over xmpp

LCA

  • Linux Conf Australasia 2010, to held in Wellington

GLPK

  • linear programming project, sponsored by GNU (hosted project)
  • applicable to lots of things – scheduling, rostering, optimising sports drafts
  • CPLEX is commercial alternative
  • MathProg is the language that comes with it, describes the program in a math like language
  • active community
  • bindings to scripting languages

XHTML2PDF

  • used for conference books and name tags
  • pdf:toc to generate table of contents from every heading
  • sponsor logos are image tags, use CSS zoom property
  • div tag used for indenting
  • margins in centremetres, told CSS book was A5
  • absolute positioing (OK for print, not for web)
  • scripts will be published
  • similar to Latex, but simple and uses same HTML as web

iPhone Hacking

  • to get SMS out – if not encrypted they are stored on your system by iTunes
  • they are GUID.mddata files which you can access using a database client
  • bambapilla – exports conversation to XML, formats nicely as XSL in browser

Hacking OSX apps with Python

  • objective C is a lie, its just C
  • when you don’t have the source but want to change a behaviour – swizzling

Patents Rock

  • protects inventors and ideas, thoughts and ideas
  • patent voliations – side to side swinging on a swing, licking a postage stamp, inducing cats with a laser light
  • software opatents suck

Haml & Sass

  • Haml – takes HTML and makes it simple and short – implementation for Ruby
  • Sass – takes CSS and makes it simple

How I PWN

Facilitating a Successful Developer Day

/ Craig Smith / 3 Comments

When an executive manager approached me a few weeks ago with the idea of running a developer day with one of his Java development teams, I jumped at the opportunity. The idea was simple: emulate the success of Google 20% time and the Atlassian Fedex day to improve the collaboration and skills of a bunch of developers.

Research

I started out with some research and found the following excellent resources:

The Running Sheet

It was decided (in hindsight, a fantastic decision) to hold the day in a neutral venue away from the usual office in a training room environment. The pre-requisites equipment-wise were at least one machine per two attendees (we ended up with two high-spec developer machines and a bunch of laptops), network access, a projector and the usual agile materials of post-it notes and pens. A supply of snacks and drinks was also available to give it a “start-up” feel.

As we had two days and wanted to also allow for some presentations and discussions, the run of the days ended up as follows:

Day 1

9.00am: Standup Introductions (All), why are we here, team building exercise (paper folding exercise)

Give each member of the group an A4 piece of paper, the facilitator needs one too. Have them close their eyes. The facilitator issues the instructions and follows them as well. No questions are allowed.

  1. Fold the paper in half.
  2. Rip offf a corner
  3. Fold the paper in half
  4. Rip off a corner
  5. Fold the paper in half
  6. Rip off a corner

The group can now open their eyes and find that there are many different shapes of paper. The debrief covers the need for two way communication and that the different perceptions of the people caused the many different designs. If time permits the group can be put in pairs. Have the pairs sit back to back and repeat the exercise using two way communications and find that the patterns come out closer

10.00am: Presentation (Agile Tools & Maturity)

11.00am: Brainstorm / Retrospective: What would make this a better team -> how can we make a difference in 24 (8) hours

The idea was to review the good and not so good of the team and help determine the issues the team would like to tackle.

12.30pm: Iteration 0 / Planning / Lunch

Melbourne GI Developer Day Rules

2.00pm: Iteration 1

Including a quick planning session

3.30pm: Iteration 2

Including a quick retrospective and planning session

Day 2

9.00am: Standup

Overview of highlight of yesterday and what planned to do today.

9.30am: Iteration 3

Including a quick retrospective and planning session

10.30am Iteration 4

Including a quick retrospective and planning session

12.30pm: Developer Practices discussion / lunch

Based on the development practices prescribed on the Donkey open source project.

1.30pm: Iteration 5

Including a quick retrospective and planning session to ensure ready for the 3pm demo

3.00pm: Demo Showcase

Melbourne GI Developer Day Demo

4.00pm: Closing Statements and circle

The Outcome

Well, it turned out better than I could have imagined! Iteration 0 everybody turned a bunch of PC’s in boxes and chairs and tables into 5 distinct teams. Story walls went up, planning started and the software required was downloaded (or people remotely accessed their work machines). Pair programming naturally happened (the limited number of machines helped this) and teams supported other teams when they ran into problems or needed assistance.

Melbourne GI Developer Day

The 5 teams focussed either on stuff they wanted to learn or things they wanted to achieve to help their everyday work. The projects attempted roughly consisted of:

  • a mobile web application using the Play framework
  • investigation into using JMX for application monitoring
  • automating WebSphere environment creation with JACL / Jython scripts
  • scripting legacy mainframe account creation for testing purposes
  • performance testing using JMeter and The Grinder

The morale was high at the end of the two days, everybody clearly learnt something and the developers were asking when the next event was. Success!

Version Control and Git

/ Craig Smith / Leave a comment

A couple of weeks ago, Geoff Ford and I gave an internal presentation to some of developer colleagues on version control and (particularly) the use of distributed version control and Git. The presentation is now available on Slideshare.

Dave Thomas on Maximum Software Productivity – Breaking The Rules!

/ Craig Smith / Leave a comment

Dave Thomas paid a visit to Brisbane to present his talk Maximum Software Productivity – Breaking The Rules! at the Microsoft office at Waterfront Place. He set the scene by suggesting the last time he gave this talk he was innundated with hate mail from agilista and objectas! Dave promised the slides would be posted, but I have not been able to locate them if they have. Here are my notes from the session:

  • tired of need to get agile and need to get objects – both good, but got nothing from it, where is the value?
  • objects good, agile good, but are we any better off?
  • most software late, bloated, poor to maintain
  • business does not define requirements well, don’t engage or talk to the customers (NEHITO visits – “Nothing Ever Happens In The Office”), insist on the industry norms because that is what everybody else is using
  • storypoints – training wheels for people who don’t know how to estimate
  • IT does not estimate well, do not build continuously or automatically test (need to be prepared to write a big cheque), also fixed in technology
  • if not ready to do TDD, just stop! Scrum will only make you feel good
  • need to change the rules to be competitive
  • living in legacy due to OO mud ball – legacy is code where there is no tests (see Brian Foote – Big Ball Of Mud)
  • objects too hard for normal people, first thing to be voted off the island should be Hibernate, objects don’t work for lots of things (queries, rules, transformations, etc…)
  • 80% of objects are CRUD – no objects except for the junk in the middle – just data, no simulations or data model – taking a solution and making it complicated and slowing it down
  • frameworks – so many to choose from, new versions, latest things, lots of dependencies
  • dependency injection is proof of how much we have screwed up objects
  • object libraries are unstable and languages are complex (attributes, generics, concurrency)
  • very few people use interfaces properly and keep them stable release to release
  • little reuse – promise not a reality
  • serialization carries all of the baggage of the objects contained within
  • objects suck up performance and memory – bulky and computationally expensive
  • objects cumbersome and slow for multi-core processors to run efficiently
  • objects are sequential and parallel
  • Java application will be 4 to 5 times slower than PHP, because objects are slower
  • can we shorten software value chain – shorter, faster, cheaper – Facebook built in PHP but the money rolls in
  • agile shows predictability and productivity but zip about quality
  • agility is good, but in Java it is very difficult to change the code quickly
  • scrum increases morale (everybody feels better), but makes no difference to quality unless doing TDD
  • lean thinking – software waste – if not prepared to spend $2 million to do continuous integration and TDD then they are not serious about their software output and quality
  • don’t go to meetings unless it is increasing the bottom line – will it help ship code?
  • how to make zero defect code? Don’t ship anything!
  • lean – simple – why am I doing this? – do we need a new framework? – NO!
  • staff a team with people who have shipped software (have a track record)
  • fix price your consultants and enforce that they make delivery with acceptance tests – pay when they pass
  • reward people on delivery, not how long they work
  • tangible requirements – story on the front, acceptance criteria on the back, start with acceptance tests, they are more valuable
  • envisioning – what the developer sees is not what the customer wants
  • agile great for prototyping – building small requirements on the fly
  • a backlog filled with lumpy requirements will burn out designers and product owners – original Scrum paper said sprint 0 should be 3 months – envisioning
  • architects – not a job, a role – should be able to code
  • some companies pay senior developers same as VP
  • extreme design – four hours to design software and hardware and cost it – after a few, you can get close and find out quickly what you don’t understand
  • serious engineering needs design
  • API first – design the architecture, should always be able to get architecture from the code (push a button)
  • need API’s versioned in the code
  • want to close gap between needs and solution
  • a picture is 1,000 words, a table 200 and a diagram 50
  • table driven programming – easily understood, easy to refactor, easy to consistency check (look for missing data), easy to version and diff (just data), data driven can be changed live in a running instance
  • integration – talk to old systems use RSS/ATOM feed (almost all old systems will give a feed for each transation) then you can talk it without custom api’s, REST/JSON your services or use ODBC as a simple interface (its not just for databases), use mashup tools to deliver an integrated application view
  • use scripts to save time & dollars – most software gets thrown way even before turned on, C# and Java too heavyweight, Ruby, Python, PHP, Groovy, Clojure, can easily leverage cloud services and existing services
  • productive languages – LINQ and Reactive LINQ (Haskell underneath), Erlang (good for swicthing and moving traffic, highly efficient), F#, Ruby, Scala (a better Java), Kleisli (bioinformatics), Clojure
  • Everybody should read “The Wizard Book”, Structure and Interpretation of Computer Programs by Abelson, Sussman, and Sussman
  • hardware is cheap, cloud is cheaper – all interesting data is in memory, databases are just journals and don’t really exist, Google does everything by brute force search (eg. translation), speed now means complicated stuff can be done easier and cheaper
  • data driven – massive storage means we can store it all very cheaply, run smart algorithms to determine best value customers because we have all of the data, recommendation engines (NetFlix), Net Promoter, complex event processing (open intelligence), real time financials (no end of month financials, know state of company all of the time)
  • query oriented programming (QOP), Greenplum, Q, Aleri (basically extended SQL dialects with functions) and other functional languages
  • array VM’s – better than object VM’s – always boxed, simpler garbage collection, support all data types (array of stuff is an array of stuff), VM can be small (just an interpreter), arrays are column stores already and trivially serialised, take less space and programs concise and compact
  • best practices for functional programming – agile , refactoring tools, FindBugs / Lint
  • challenges for functional programming – get out of math phobia, different way of thinking, need to write literate and understandable code, think in functions
  • yesterday and tomorrow is always wrong – if you get more bang for buck and competitive advantage, why use existing technologies, if you believe IT is strategic you need to do something strategic with it and dare to be different
  • lost of old things work, lots of new things work well, get out of agile and OO box

Barcamp Brisbane IV Wrapup

/ Craig Smith / 3 Comments

Barcamp BrisbaneLast weekend I got along to Barcamp Brisbane IV (held at the East Brisbane Bowls Club), and once again it was a worthwhile meetup of locals willing to share their skills with others.

From the lightning talks that I attended:

Speed Networking

One minute to introduce yourself to someone you don’t know. Worked well, although I knew more people this time around (after last BarCamp and other meetups).

Search Engine Optimisation (SEO)

Michael Smale led this discussion on SEO (unfortunately it started a little late and lost a bunch of attendees, including myself, at the end due to a Google Wave presentation following it!). My notes from the session:

  • SEO is optimising for Google (& Yahoo!)
  • 9 out of 10 people search for content, very few click the sponsored search
  • keywords – on page (to help Google index) and off page
  • stem analysis – trunk and branches (eg. golf and balls, clubs, shoes) then leaves (buy golf shoes and Brisbane) – before SEO, find out what target audience is looking for
  • tools to analyse keywords – Google Adwords Keyword Tool (slightly out of date, monthly), worldwide but narrowed down to regions
  • to know backlinks, etc – Traffic Travis, Market Samurai (free and paid version)
  • not your trunk and branches, but for your leaves you may want to buy keywords, you can optimise different landing pages (separate URL but not a duplicate of pages as Google will drop prioritisation)
  • car rental very competitive for SEO
  • Google Trends for search – can see if things are trending up and down or compare
  • on page optimisation – Firebug for Firefox – drill down and inspect code, JavaScript debugger
  • YSlow – tell you how page is loaded and report on how to optimise page loading
  • each page needs to be optimised with its own title – what’s in the title is what the link on Google says
  • meta description after link is the blurb on Google – not visible to users on site, Firebug will help you see competitors meta tags are, but will not get you up in the ranking
  • meta keywords – does not mean anything anymore
  • care about content on site using LSI (Latent Semantic Index)
  • link text important, add href no follow so Google will ignore

Google Wave

Paul O’Keeffe and Steve Dalton led a live demonstration of Google Wave.

  • collaborative tool, still in preview, crashes, interface still weak
  • proliferated from developers in Google sandpit, only give 8 invites to each user
  • a wave is a single collaboration / conversation
  • has Gmail feel, add and save searches, folders, etc…
  • have a wave inbox
  • with:public – see any waves that are public
  • search with:public gardening
  • new wave by default is not public, add public@a.gwave.com
  • to start, drag contact in, give wave a name
  • drag and drop seems to depend on Google Gears, works out of box with Chrome
  • bots and plugins eg. pirate speak or add a Google Map / Twitter in
  • open source version of Chrome – Chromium
  • Sweepy bot – remove the empty conversations
  • can mute conversation and replay, has version control so you can see how it was and then fork it off

Business Structures

Malcolm Burrows from Rostron Caryle gave this presentation. I hope the slides are made available, as this was a large topic for a 20 minute slot. These are my notes but should not be relied upon an advice or for accuracy!

  • sole trader – liable for own debts, etc, house on the line, no protection freom risks, okay if you have little risk
  • partnership – not sure why anybody would do this now, agreement and governed by those terms, in Queensland partners are liable for acts of the other, everything has to be tailored, risks
  • company structure Pty Ltd – level of risk reduction such as corporate veil, shareholders only liable for the capital put in as long as you don’t do stupid stuff like trading insolvent, as directors do not profit from position of power, need to disclose, 12/20 rule can’t make more than 20 offers in 12 month period, no more than 50 shareholders, replaceable rules (eg. regulate by ASIC or regulate yourself in your constitution)
  • company structures – Limited – Public – all of baggage of public company without the good stuff, horrible!
  • trust – discretionary and unit
  • joint ventures – used a lot in mining, in IT where people agree to do stuff, like a trust is a feature of contract, rights of joint ventures can get very long
  • income distribution structure and IP protection structures
  • options for IP – spin out trading company, spin out company owned by trusts, spin out company licences another

Smile! Say Cheese!

DJ Paine from Studio Promise dropped by, and offered attendees a free portrait, which I certainly took advantage of. Just wished I had of known, and I would have had a shave and worn a nicer shirt!

All of the shots from the day are here and if you need professional photography, support those that support BarCamp!

Symphony – Open Source Content Management

Allen Chang and Alisair Kearney led this session on Symphony:

  • originally called TypeWorks
  • 2.0.6 out now, 2.1 on the way
  • uses XML as data format, output format standards compliant
  • Drupal and Joomla! cores are huge, they wanted a small footprint and control over data structure
  • use XSLT to transform XML to any format you like (eg. HTML, CSV, JSON, etc..)
  • native intergration REST API for Twitter, RSS, etc…)
  • uses open standard templating language, as per all CMS systems
  • a number of data sources for which you can apply rules
  • around 8,000 members, 10% of these contribute
  • users include Australian Museum of Democracy, Heineken and City of Westminster (London) amongst many others
  • ensemble – fully functional website package, Symphony itself is an ensemble

Agile Overview – The Three T’s

It occurred to me in the speed networking session that a number of attendees did not know what this agile hype was about, so I decided to on short notice to propose the talk I gave at Agile Australia 2009 to try and give that overview. Not sure if I succeeded, but got some questions afterwards nonetheless.

Had to laugh at one of the tweets from @funkygorilla (Simon Griffiths): “Agile web development in a 10 min presentation. That’s agile!”

Overview of Agile 2009 / Agile Australia 2009 / AAFTT Workshop

A couple of people decided they wanted to chat about some of the learnings and trends from the conferences I had recently, so a couple of us sat around and chatted about agile testing mainly.

New Hotness

Greg Luck led this discussion as he mentioned to me he came to Barcamp to hear about the new hotness. He has written the notes, but here were the notes I was taking at the discussion:

Wrapup

Paul and Steve reminded everybody about the Queensland Legion of Tech and Greg Luck announced the inaugural Brisbane Jelly (adhoc working together at a location)

Agile Australia 2009 Day 2 Review

/ Craig Smith / Leave a comment

Agile Australia '09Day two of Agile Australia kicked off with a breakfast to discuss facilitation of the open space sessions later in the day, that I was lucky enough to be invited to participate in.

Once again I would have liked to have attended Phil Abernathy’s discussion on agile governance (video), Lachlan Heasman and Jody Podbury’s discussion on Agile Business As Usual (presentation) and unfortunately I was scheduled at the same time as Rowan Bunning’s talk on Agile Mistakes and How To Avoid Them (presentation).

Here is an overview of the sessions I attended:

Keynote – Increasing Business Value Through Simplicity

Jeff Smith, CIO of Suncorp gave this keynote, and whilst I have heard a version of this talk a number of times, it never fails to inspire!

Some of the quotes from the talk included:

  • “There is no technology constraint. The only constraint is constraint of thought”
  • “Every product can be copied, but you can’t copy culture”
  • “We don’t do any actual work as leaders, we create the environment for others to do so”
  • “Leaders must important work is to create a productive environment”
  • “When selecting a team, availability is not a skillset”
  • “Leaders should use passion instead of fear to get things done”
  • “There is no skills shortage, there is a shortage of leadership”
  • “Productive Partnerships – work with people you inspire to be like”

ZDNet also summarised this keynote: http://www.zdnet.com.au/news/software/soa/Free-interns-boost-Suncorp/0,130061733,339299090,00.htm

Lean & Agile In The Large

I have seen this talk by Dave Thomas before as well, but wanted to enjoy it again!

Some of the quotes from the talk included:

  • “Smell is a valid engineering term and will soon be a valid business term”
  • “You know you’re agile when you no longer have DOORS, Mercury or MS Project“
  • “You can only improve what you can measure”
  • “To be agile all the way up you need to be lean all the way down from the top”
  • “You need to have someone on your team who’s seen the movie before to be successful”
  • “You must reach outside your own circle of influence to build a community”
  • “If you happen to think that UML is useful then generate it from your code”
  • “Learn your tools. You can’t do TDD unless you know keyboard shortcuts”
  • “ Done = Acceptance Tested!”
  • “A story is a wish unless it has acceptance criteria”
  • “Architecture is a role not a job”
  • “The ultimate expression of process is a culture where building software is more like playing jazz. People just do it!”
  • Definition of SWAG – “Software Wild Arse Guess”

Understanding Just In Time Requirements To Support Lean Software Development

Martin Kearns from Renewtek delivered this presentation. My key takeaway was to remember to scout ahead to be successful.

  • grow change – yourself -> team -> organisation, need to influence your team, change your world and the world around you
  • Toyota production system – two pillars including Just In Time (JIT), falls down without it
  • JIT is about a need – teams want to understand what they are delivering beyond the sprint
  • takt time – theoretical figure on how long it takes to make a product, compare to total cycle time to look for waste (eg, 2.5 days to build car and 4 weeks to deliver, where is the waste?)
  • continuous flow processing – re-arrange for work-piece flow, kaizen to solve bottlenecks
  • one piece flow helps identify quality, ask these questions in retrospectives
  • batching – push process
  • kanban – pull the work – get team to dictate what they need and when they need it, gets team commitment when you supply their needs
  • power of team based approach – able to direct each other and influence the organisation
  • Ron Jeffries Three C’s – card, conversation, confirmation
  • be aware of never ending stories – chasing tail, not sure what we are creating
  • need to scout ahead – to be productive in the now, need to spend time looking ahead to manage uncertainity
  • 5 levels of agile planning (Rally) – 1) visualise what we want to do 2) need a roadmap to know when things are coming so we can focus on the now, need to trust and challenge the roadmap 3) release – incremetal focussed on an outcome, reflect and recalibrate  4) sprint try to get sustainable pace 5) course correct daily
  • project bridge – how are people going to critique our work
  • people want strategic direction – put a date range around release dates
  • understand concept, then formulate a high level design (can be photo on a wiki), should not be done in sprint planning because it can bring uncertainity, implementation,  specification
  • concept – visualise accomplishments and how to communicate to the team
  • need trust and openness – barriers is not a team
  • take baby steps and work your way through dysfunctions

Lean Thinking for Lean Times

Jason Yip from ThoughtWorks and Alan Beacham from KM&T delivered this presentation. The slides are available here. It was a good overview of Kanban (it allowed me to get that a-ha moment in relation to measuring flow).

  • best source of information is Kanban vs Scrum by Henrik Kniberg
  • most agile shops already have a wall with steps, kanban trying to show full process and make explicit, visualise hand off points, set limits on the capacity (otherwise burden people and nothing actually moves)
  • Corey Ladas – Why Pull Why Kanban – JIT backlog – only do what you can do, lean has articulated what XP folk were talking about
  • event triggers – order point to trigger upstream process so not starved of work
  • size of cards now hard to relate back to customer value (software by numbers – minimal marketable features), so track both on wall (feature and then stories and tasks)
  • standardise size of work items instead of estimating (so just tracking work estimates) – at ThoughtWorks Jason determined everything is 2.25!
  • Kanban – means card or sign – referred to as signboard in a pull system
  • allows to understand consuption rate (how much work in progress)
  • manages amount of work, flow of materials and understand when people work
  • left to right thinking not the way, donlt understand the problem when you start, usually do 80% of project in last 20% of time, kanban brings to the front
  • schedule from right to left, process goes left to right, fixed date and desire, requires innovative thinking
  • kanban is growing trend, challenges fundamental concepts (eg CSM training), has to be suited to the type of work

The Inter-Sprint Break

Simon Bristow from Acnoex delivered this presentation. The presentation is available here. My key takeaway were the many techniques used throughout the sprint and in the break.

  • Aconex – have a break between sprints
  • Scrum is unstopbbale momentum
  • a holiday or time to kick back – no!
  • 3 week sprints, sprint planning at start and demo at the end
  • start sprint on Tuesday and finish on Thursday – so 2 day break
  • benefits – teams were stressed and burning out but then got extra benefits
  • track at retrospectives the mood-o-meter and stress-o-meter – mood started high, dropped low throughout sprint and raised at end of sprint again and stress low but raises at end of sprint
  • team used to have 6 month releases, now they think 3 weeks is too long
  • asked team to draw pictures on how they thought sprint went
  • were looking for consistent level of mood and stress
  • distractions and flow – always other stuff during the day not related to doing sprint work, when you take somebody away from task there is waste as they ramp back up, made rule that meetings were moved into inter-sprint breaks such as management one on ones, brown bags still run at lunchtime because it is useful
  • collaboration – classic IT/business divide but also discipline silos (test, UI, middleware) – moved to a cross functional team, used scrums of scrums
  • in intersprint break – strategic planning, technical debt for discipline, information sharing, improvements in tools (changed toolset from JUnit to TestNG in two days and got immediate improvements)
  • paying down technical debt – argue that if technical debt is important it should be in our sprint backlog, but this only allowed them to focus on parts of the system they were changing and not the system as a whole
  • war on warnings – complier warnings
  • testivus – refactor or add new tests
  • QA deathmatch – find a bug get a point, fix a bug get a point and prizes for most points, fun activity and some competition, keeping the garden free of weeds
  • innovation – need time to breed creation
  • hackathon – like Atlassian Fedex day – can do anything with any technology for any purpose, demo something that can improve product or look at new tools, gets creative juices flowing, lets IT show the business we can tackle anything
  • extended to researcharama – like hackahton but not to produce prototype but present research to increase knowledge of teams
  • looking to do howhardi gras – answer question how hard would it be? response, take some of those questions to pick it up and have a crack at solving it
  • things you get for free – product reflection, think about team actions from retrospective, admin catchup
  • things to watch – don’t make it too long or sluggish to get back to sprint, activities for all, clear outcome and purpose, have a champion
  • during the sprint keep sustainable pace and don’t use intersprint break as excuse to leave things
  • sell to business – constant sprinting understood and can cause burn out, started with hackathon to demonstrate importance
  • draw a map of sprint to find major events (PC broken, etc), then get team to draw their mood on top
  • use a thumbs up, thumbs down, OK in standups
  • sprintometer – identify how we are travelling visually, get somebody to move this at the end of the sprint
  • called Gatorade Breaks elsewhere
  • have already determined the game team will play in the break, maybe should ask team what they want to play, been based on what has been going on in the organisation
  • have a tendency when sprints go bad to use break to catch up , champion needs to ensure that they get the activity done
  • transparent and business aware of release cycle and to use break for distractions, trying to hammer distractions and bad flow
  • prioritise BAU work in backlog, must talk to Scrum Master, for silo teams have to constantly remind managers that speaking to a team member affects productivity
  • all sprints synchronised, originally thought it was good idea to stagger for room bookings, etc, but all teams together ended up working much better

After The Consultants Leave

Adam Mostyn from BT Financial delivered this presentation. The slides are available here. It was interesting to hear the successes and failures in what I thought to be an environment that would not be receptive to agile.

  • Phew, go back to what we did before
  • started in 2006, not looking for agile but for bright people to attack a skills shortage
  • showcases worked well (especially beer and pizza to get people in!)
  • storywall worked well to see progress
  • user stories, standups both stuck
  • product owner did not stick – went back to old way of handing requirements over, showcases fell by wayside, sprints fell by the wayside because not ingrained in culture
  • did not have education and understanding what agile meant – business had thirst but projects started to fail
  • have resistance from business – need to convince it is a methodology that has rules
  • need to convince that agile is a journey and not a switch
  • ensuring that they have qualified Scrum Masters on every project team, otherwise will fall into same hole
  • trying to define the role of product owner
  • fun, so engages and empowers staff

Achieving Project Success With Agile

The session I presented, I think got a reasonable turnout for the last session of the conference on a Friday afternoon. The slides are available in a separate post, but are also available here.

Agile Open Space

I facilitated a session on agile technical issues (amongst 13 simultaneous discussions). We discussed TDD, automated testing, pair programming amongst other topics.