Striving for better ways to write code

Startup Lessons Learned Conference

Yesterday was the Startup Lessons Learned Conference in San Francisco. Although I heard it was a beautiful day in SF, I enjoyed the conference from Cambridge, compliments of the Lean Startup Circle – Boston. It was a great day, met a lot of interesting people in Cambridge, and heard a lot of interesting folks via the simulcast.

This was my first time at a meetup of the Lean Startup Circle in Boston and I really enjoyed it. The group may gravitate a bit to the entrepreneurial side, but that is not unexpected. Still I would like to see a broader spectrum of people and industries embracing the ideas of lean/agile, but it is a movement and that will take some time. But thanks again to Matthew Mamet and John Prendergast for putting the event together.

Keynote – Eric Ries

Eric Ries kicked things off with the keynote. The takeaway for me here was the definition of a startup:

A human institution creating a new product or service under conditions of extreme uncertainty.

It has nothing to do with the size of a company, what industry it is in, how it is funded, etc. We need to develop practices that are geared towards managing and responding to that uncertainty. He talked a lot about the Build, Measure, Learn loop (which Kent Beck later turned around to the Learn, Measure, Build loop), ways to fail fast, and knowing when it was time to pivot. If you follow Eric’s blog there was not much new here, but he was setting the table for the presentations and case studies that would follow.

Build, Measure, Learn – Kent Beck

Kent Beck followed Eric Ries. Kent was part of the Agile Manifesto and invented test-driven development and pair programming. As a developer, TDD and pair programming are two of the most powerful tools/practices I have seen in all my years. As I mentioned earlier, Kent talked about the Build, Measure, Learn loop, which makes sense from an engineering/development point of view, but by running the loop backwards, we are pulling the build (from Lean Manufacturing‘s concept of pull) from what we learn.

Kent also went through other aspects of the Agile Manifesto: people over processes, collaboration, accepting change. He was preaching to the choir, so he didn’t go into too much depth. He did go into some depth on knowing when to live with a simple solution to get a product out (he used the term “hackery”) and when you need to refactor. As an example, he cited Amazon Dynamo. At the scale they operate at now, this is an essential service, but if the had tried to start with that, they would have ended up in the scrap heap. As a developer, I have seen many projects get behind by over-designing or over-engineering early on. Getting out there early allows you to see if you have a viable product and as you learn more about usage/features you can refine your design and implementation.

Agile Development Case Study – Farb Nivi

A real highlight for me was the Agile Development case study at Grockit, by Farb Nivi. Farb went into a lot of great info about accepting change/chaos, how to write good user stories (make them narratives, not “to do” lists). He talked about an Agile planning tool they use called Pivotal Tracker that I need to take a look at. His presentation also had a very cool feel to it and was done with a tool called Prezi.

The thing that really caught me about Farb’s presentation was the development culture and the way they have embraced pair programming. The interview process at Grockit is simple. Candidates come in and pair program with one of the development team. I can’t think of a better way to get to know whether a candidate is someone I would want to work with and has sound software engineering skills. I have had a few posts on the value of pair programming and the challenges in getting more developers to adopt it, so having this question about a candidate answered up front is invaluable.

Grockit’s philosophy on languages is simple and straightforward too. They don’t care what languages or tools you have used, if you have good skills and work well as part of a team you will be able to produce good code in whatever languages they are using. That is an incredibly refreshing and enlightened attitude (although on their website they say you need to have programmed in Java and Ruby for at least a year. Jeez, Farb which is it LOL). Developers at Grockit spend 70-80% of their time pairing, with the reminder spent on spike’s or some other stand-alone tasks.

Getting to Plan B – Randy Komisar

After the break, Eric Ries sat down with Randy Komisar in a talk titled “Getting to Plan B“. This was a great back and forth discussion between Eric and Randy. Randy talked about answering the “Leap of Faith” questions. These are the questions that you need to answer, that if you don’t know the answer to will kill your product. They can be technical, marketing, whatever.

Randy also talked about the importance of a “dashboard” to guide you and track your progress: are you measuring the right things to answer your leap of faith questions. I found some interesting articles with the Sloan Review and Sramana Mitra that touch on a lot of what he talked about. When the presentations go online I strongly recommend watching this presentation.

In Closing

There were several other good presentations, more than I can write about. When the presentations go online I strongly recommend checking them out and finding the things that hit home for you. And thanks again to the folks at the Lean Startup Circle – Boston for putting on the simulcast and giving a place for people to get together and exchange ideas.

Update: The videos from the Startup Lessons Learned conference are available on justin.tv

Post navigation

6 thoughts on “Startup Lessons Learned Conference”

Thanks so much for the great summary. I also like Eric’s definition of a startup and Kent’s Build, Measure, Learn. I was hoping to attend (well, via Cambridge, like you did) but wasn’t able to get down for it, so I thank you for the write-up, maybe I’ll see you at one of their future Meetup’s.

TDD is great! A former colleague said that without it, he feels like he’s jumping without a parachute, and I agree. After having moved onto a project near the end stages that didn’t incorporate any developer level testing, I have certainly felt the pain in terms of both overall quality and regressions introduced by critical bug fixes that could have been prevented.

Do you think Pair Programming is as useful overall? I think it’s great when you have two compatible individuals, but I haven’t seen any data on improving software quality or improving output considering all the different personality types you get in engineering. Do you think this has the same “borderless” advantages that TDD provides?

I think pairing is an incredibly valuable tool, and I wish I was able to do it more often. It leads to better design, less code “ownership”, offers a great learning experience for both senior and junior developers. I don’t have any data, just my own personal experiences.

The personality/compatibility issue is a real challenge. I have never found myself in a situation where the two people couldn’t come to agreement, but I’ve been fortunate to be on some great teams where there is always respect when there are disagreement.

Another issue is that some people are uncomfortable with pairing, and prefer code reviews. I prefer pairing to code reviews because with a code review, the horse has already left the barn. They serve similar purposes, but pairing to me is more proactive. I wrote about some of the challenges of pairing here. I think the way Grockit works it into the interview process is a great idea. It resolves the issue of whether someone is willing and able to pair while at the same time gives great insight into someone’s technical capabilities.

Thanks for posting links to the videos.. ive never been in an environment where i can pair up and swap ideas,. its usually just me arguing with the graphics team which is a hundred miles away. I’m not done watching the videos yet im at flowtown.. my minds running right now i had to say thanks.