Our setup:

• Jenkins CI, installed on a virtual Ubuntu server,
• Android SDK on the Ubuntu server,
• Android SDK compoments (including an Android profile/ target),
• an Android project
• keytool on Ubuntu to create a simple keystore, for signing the app

The gist of the Jenkins job is:

• Get updated code from Git
• Execute shell command to create an ant build file on the fly with the Android SDK tool android:

/opt/android-sdk/tools/android create project -n [name of resulting app file] -t [Android target] -p [name of temporary directory where project is copied and ant files generated] -k [package] -a [default app class]

• Copy resulting build.xml from the temporary directory to the project root
• Run ant targets clean release, with the following properties:

sdk.dir=/opt/android-sdk
target=[Android target]

key.store=path-to-keystore
key.alias=[alias]
key.store.password=[pw]
key.alias.password=[pw2]

• (Without the last four properties above the job will build an unsigned app)
• Publish resulting .apk via FTP to a server

And on my phone:

• Allow installing apps from unknown sources

I got useful info from an article on jenkins-ci.org:  Getting started: Building Android apps with Hudson. My needs were a bit simpler, so you’ll see a bit more details there than here.

A few problems I had:

• The Ubuntu VM didn’t have X installed, and getting SDK components seems to require a GUI. I tried to go around this by copying tools and targets from SDK on my laptop.
• A bit later I got stumped by an error message on aapt and “no such file or directory”. (This might have been related to what I did on the previous problem…) An answer on stackoverflow regarding ia32-libs provided the solution in my case.

This project is a side project with low activity compared to a day job, so right now this job is a one-click deploy job (one click plus downloading and installing on the phone…) However, I think we’ll set up nightly polling, so there’s an updated app available every morning for testers, and they can see by the timestamp  if there were any updates the previous day.

From the abstract:

The evidence shows that over the 12-month period, lead time to deliver software improved by 37%, consistency of delivery rose by 47%, and defects reported by customers fell 24%.

The significance of this work is showing that the use of lean methods including visual management, team-based problem solving, smaller batch sizes, and statistical process control can improve software development.
….

The faster delivery with a focus on creating the highest value to the customer also reduced both technical and market risks.

There’s more info on David’s blog, and you can also read the case study itself prior to publication from there.

Focus on work items, not people.

Then:

Finishing is more important than starting.

Practical tip: start to the right/ at the end of your board, and identify impediments to finishing tasks as you go upstream on the board.

Only two questions are really necessary in the actual standup if the team’s real process is reflected on the board:

 The team will be asked if the board accurately reflects what is being worked upon. The team will be asked if there is anything that is slowing down or stopping throughput. After these two questions are answered by the team, the stand-up is over.

(Karl Scotland via @dpjoyce.)

Here’s what I think:

• Goals: rapid feedback, fail fast, always releasable, simple (i.e., easy to use)
• Visibility is important here, too: Everyone can see what’s happening

Mainline and CI

• There should be a mainline – Everyone Commits To the Mainline Every Day
• IMO, the mainline – i.e., what you are working on every day – should be ready to release from at almost any time. This implies low technical debt, and little difference between mainline and a release branch (if you use that) – i.e., less work in progress at any time.
• Maybe a release branch is a good idea - where you actually can release from at any time

• Beware of feature branches, and kill them as soon as you can if you do use them. (One tip: feature toggle)
• Branches: Merge from mainline every day if you have them.
• Good naming goes for build code and infrastructure, too, so I’d prefer branch names like mainline, release, featureA, fixB
• Limit branches agressively – they represent more work in progress (and you want less work in progress) including risk of big merges
• 

  Illustration from Henrik's article

  Merging: merge down, copy up – always accept stabilizing changes, never impose destabilizing changes.

Inspiration:

Martin Fowler: articles on continuous integration

Henrik Kniberg: Agile version control with multiple teams

Det finnest ei facebook-gruppe og ein presentasjon med litt info, sjølv om det er litt gamal info der.

Under er ei lita hugseliste for å setta opp fast betaling til dei.

• Du kan bruka kontoen til Stiftelsen Dina, konto-nr 3080 21 65400
• Merk betalinga med “Uganda”
• Det skal gå melding til skatteetaten om skatte-trekk for frivillig gåve, men det er sikkert greitt å sjekka når sjølvmeldinga kjem

For a few days it might be a bit unstable here…

• Visualize work; items, process/ flow, policies
• Limit work-in-progress (WIP), but don’t be too ambitious at first

Basic Kanban is a lightweight framework for change management.
Starting with the core concepts on top of your present process should meet little resistance, at least when coupled with focus on improving quality.

Btw, I talked at a lokal meetup earlier this year (slides here), mostly on the core concepts – why they work and how to start.

A few Kanban Practices

• Flow; encourage, cultivate, transform towards
• Classes of Service (CoS); visualize and track different types of work, with different demands on them
• Gradually limit WIP to improve flow and to uncover your next improvement opportunity
• Cadence; regular rythm of things like backlog replenishment and deployment, separate from development
• Metrics; to manage flow over time
• Pull; instead of mostly work with deadlines
• Slack, swarming – doing it consciously

There’s more, but this illustrates the relation between the core concepts and a set of recommended practices.

You’re likely to start with a simple version of some practices, f.ex. the work types (CoS) critical items, work with deadlines, bugs. More practices can be utilized as your organization matures, and more sofisticated use of practices, like setting different target lead times for different CoS, f.ex. 50% of bugs should be fixed within a week.

(Re-posted from notes to self.)

Update after “conversation” with @pawelbrodzinski: Buy-in from management and whole organization is preferable, but team buy-in is enough and necessary, in my opinion.

I think it’s important to just get started, improving step by step, and team buy-in and the Core Concepts are enough to do that.

So I simply had to create a personal kanban on the cupboard behind me:

Collaboration on the demo preparation led to tasks on the board, and I took the most important and urgent tasks from my todo lists onto the board.

I used a form of priority filter, with a generic todo column to the left, then a “soon”/today column, then the usual doing and done columns.

It worked really well to let tasks float up and to the right in the todo columns, kind of like bubbles. I got an immediate impression of relative urgency (more to the right) and relative importance (upwards), making it very easy to decide what the next task should be when I finished a task.

I think it went well, even if I made a few presenter mistakes, based on feedback and the great questions and discussions.

Here’s the presentation with a few adjustments, like a few additional links for further reading.