David Bock

Presentations

Surviving Middle Management

Most good developers eventually have the opportunity to be managers. Whether they call you the "project manager", "Technical Lead", "Lead Developer", or some other classic middle-management title, you become the 'goto' guy between management and developers. You're the guy who is expected to keep the project in-line, track a schedule, and occasionally answer the question "How's it going?", and perhaps still contribute at a technical level. So how do you do that?

So what do you do next? How do you plan what needs to be developed? How do you know if you are 'on schedule' or heading off-track? Using good ideas from a bunch of successful projects (but no methodology in particular), you will learn the basics of good project planning, execution, and tracking.

While this talk as management methodology agnostic, many of the ideas are tracable directly back to concepts from XP, SCRUM, and even RUP and CMMi. Whether you are following a management methodology or not, the ideas in this talk will be applicable to technical managers.

Intermediate Maven

Maven is a build tool that does a lot, demos well, and leaves the build maintainers managing what seems like unbridled complexity. It doesn't have to be that way - Maven is driven by some strong 'build process methodology', and that complexity can become manageable by wrapping your head around it. Furthermore, you can migrate to Maven 'piecemeal', by mapping your existing ant build to the Maven Lifecycle and calling your existing Ant tasks - you can decide to sip the Maven kool-aid.

Ideally, a build tool should be so simple and approachable that it fades into the project background and allows anyone to maintain it. Unfortunately, Maven's power comes at the expense of this ideal - Maven's philosophy is more like "the build process is so important that the people maintaining it should be steeped in the ways of Maven". This talk will give you the exposure you need without elevating The Maven Way to a religion.

In this talk we will cover:

Internals of the Maven POM Integrating Maven with Eclipse The Maven Build Lifecycle, and hooking your own goals into it Calling Ant tasks from Maven Extending your build with existing Maven Plugins Maven subprojects and the SuperPOM Writing your own Maven Plugins

Estimating vs. Guessing - How Agile Teams Estimate Their Work

Estimating is regarded as little little more than 'educating guessing', but so much can hang on the quality of those estimates. With good estimates we can set clear expectations for project delivery, but with bad estimates we can run over schedule and over budget, or worse. We often estimate when we know the least about the work that needs to get done - so how can we make the best of what is potentially a bad situation?

In this session we will look at how successful agile teams estimate the scope of work at the beginning of a project, estimate the amount of work that fits into any one iteration, track the work through the iteration, and the 'burn down' through the end of the project. We will look at 'low ceremony' estimation techniques like planning poker, trim down 'high ceremony' techniques like Wideband Delphi, and look at "FET+", an estimation technique originally developed as a foil for a CMMi effort.

With a little effort, a little planning, a little tracking, open communication, and some good metrics, estimation does not have to be a 'crystal ball' activity.

The Agile Product Owner

Agile software development isn't just about the development team or managers... the customer has an active role too. The customer should be prioritizing the stories in each release, potentially working onsite in constant contact with the development team, and even participating in daily status meetings.

Done well, the customer's presence has a positive influence on the development iteration. Done poorly, the customer detracts from the team's focus. So how do you be the customer of an agile team? How do you teach someone to be that customer?

In this session we will look at an overview of agile methodologies and the role of the customer, customer proxy, and other versions of the "product owner", and their responsibilities in ensuring the success of an agile software development project.

Memcache: Show Me the Money

Memcache is a simple, powerful tool for adding caching to your server-side application processes. With APIs for just about every language in use today, you can put and retrieve chunks of data, pre-rendered html, sql result sets, and other things that are 'computationally expensive' to generate the first time. Memcache is in heavy use by sites such as facebook and twitter... come see how it can fit into your application's architecture.

In this talk we will show how memcache works, how you can use it, and discuss some of the perils and pitfalls when caching data for performance and scalability. We will see tools for analyzing your cache, testing invalidation, and discuss various cache expiration techniques.

Monitoring your Production Server with Munin, Monit, LogWatch, and other open source tools

If you are a small development shop, chances are your clients look to you guys for a little bit of everything... developing the application, recommendations for production hosting, and perhaps even monitoring the operational system for performance and security concerns. If you suddenly find yourself responsble for monitoring the health of a production application, where do you start?

In this session we will talk about the monitoring of a production application on linux, using tools that show you a snapshot of the host status right now, a running record of all machine statistics going back for as long as the machine has been running (for trending), tools for monitoring and reporting on application logs, automatically repairing some kinds of situations, and automatically "cry for help" with email, sms messages, and even phone calls when something goes awry.

What every developer should know about MySQL

MySQL is the "poor man's Oracle", right? Perhaps you've heard rough comparisons to Postgres, rumors about not supporting transactions or foreign keys, etc. The truth is that MySQL is a capable and mature SQL server that can and is used to host some of the world's largest production applications. Best of all, it's open source - It is already 'yours' to use without a huge upfront license cost.

In this talk we will go over the use of mysql in development and production - a little bit of configuration, a little bit of administration, a little bit of development, an overview of its capabilities/strenghts/weaknesses, and so on. You'll leave this session with enough knowledge to give it a shot in your own development environment, whether you are using JDBC, Hibernate, iBatis, or your own home-grown framework.

Polyglot Language Communication with Thrift

Apache's Thrift is a software framework for scalable cross-language services development. It combines a software stack with a code generation engine to build services that work efficiently and seamlessly between C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, Smalltalk, and OCaml. Originally developed for use at FaceBook, it has been released as an open source project and is now available from Apache.

In this talk we will look at Thrift from both a code and architecture perspective, show how to use Thrift for communication between processes in Java, Ruby, Python, and discuss how it is used in real-world situations to provide architectural flexibility.

Maintaining Source Code Quality (The Project Integrity Series)

How many times have you started a new project only to find that several months into it, you have a big ball of code you have to plod through to try to get anything done? Have you ever been the 'new guy' on a project where it seems like the code grew more like weeds and brambles than a well-tended garden? With a few good tools to help analyze the code, we can keep our project from turning into that big ball of mud, and we can salvage a project that is already headed down that path.

In this talk we will look at PMD, FindBugs, Macker, JDepend, and several other tools that can help us analyze source code and find problems we need to fix. We will cover each tool in enough depth for you to know what it does and how it can help you, understand its strengths and weaknesses, and see how it would fit in your personal development processes.

Managing Complexity (The Project Integrity Series)

How many times have you started a new project only to find that several months into it, you have a build process that mysteriously fails, a bunch of 'TODO' and 'FIXME' comments in the source, and problems that come and go because "it works on my machine"? Does your project have a little bit of 'folk wisdom' that isn't well-known, but is necessary to get things done? How easily could you recreate your development environment if you got a new machine today?

In this session we will talk about some tried and true favorites like Ant, Maven, Subversion, and Eclipse, cover tools like diff, patch, difftools, and diffj for teasing apart changesets, and talk about measuring and managing complexity with tools like cobertura, JavaNCSS, XRadar, CodeStriker, and Jupiter. We will cover each tool in enough depth for you to know what it does and how it can help you and your team, understand its strengths and weaknesses, and see how it would fit in your team's development processes.