Tech and Stuff

Static Code Analysis Content

allen — Fri, 27 May 2011 15:59:42 +0000

Ben Floyd and I recently did a presentation on FXCop and StyleCop. You can get the code here, and the slides here.

Ye Olde TDD Content

allen — Fri, 27 May 2011 15:52:34 +0000

Chris Weldon and I have given this presentation a few times. You can get the code here, and here are the slides.

Tale of Three Transitions Content

allen — Fri, 27 May 2011 15:27:37 +0000

The only thing I’m really an expert on is my own experience. So, I figured I should give a presentation on that. This talk is about some experiences I’ve had with groups transitioning to agile. Hopefully there’s something to be learned from it.

Here are the slides from that talk.

One year anniversary of Improving Podcasts

allen — Tue, 15 Jun 2010 18:37:22 +0000

Today we released our one-year anniversary episode of Improving Podcasts. It’s a huge milestone for us, 27 episodes released every other Tuesday with no missed weeks. It hasn’t always been easy to come up with content, but Mike and I have held each other accountable (Mike’s the one with the real discipline) and we’ve lived up to the challenge we set for ourselves. It’s been a lot of fun and some content has been outstanding (if I do say so myself) while some really hasn’t, but I think it was worth the effort.

In the latest episode I get together with Ed Grannan and Gary McCants to discuss some of our favorite episodes and add some new perspectives and opinions. If you haven’t listened to the podcast before, it’s a great place to start because it can point you in the direction of some of our best episodes, and those are the ones you should listen to first .

When surveying Improvers about their favorite episodes, I was pleased that more than half of them made someone’s list. Some that would have been in the bottom half of my list were first on other’s. I wasn’t expecting that, but it was a pleasant surprise.

Listen to our one year episode and tell me what you think.

Website Redesign

allen — Tue, 15 Jun 2010 16:03:02 +0000

I’ve neglected my personal website/blog for years. One of my goals for this year was to get it into shape and start using it for good. I just deployed the biggest improvement ever to my website.

I started with a theme I really like called Arthemia by Michael Hutagalung and customized it a bit. I added a custom homepage and added a few other tweaks. Check it out and let me know what you think!

Visual Studio 2010 LoadFest Content

allen — Tue, 15 Jun 2010 06:35:31 +0000

On June 3, 2010 I led the Visual Studio 2010 LoadFest at the Visual Studio Launch Event in Austin, Texas. It was a lot of fun. You can find the content here.

Get the slides

Get the code

Improving Lunch and Learns

allen — Tue, 15 Jun 2010 03:08:38 +0000

If you’re in Dallas, Houston, Austin, or Bryan/College Station (or within an hour or so), take advantage of Improving’s lunch and learns. We’ll come out and present to your team on a topic of your choice, free of charge. Our topics cover the latest in .NET development, Java, Object Oriented fundamentals, and, of course, lots of perspectives on Agile Software Development. If you need an easy way to expose your team to the latest in Agile development from the comfort of your own office, here’s your chance. Here’s a list of topics, but feel free to request a different one if the one you need isn’t listed. To schedule a lunch and learn, drop me a line or hit us up via our website.

Introduction to Agile Methods

Or maybe it should be titled: Agile for Dummies. For those that are new to agile or need a quick refresher, this session provides a broad introduction to the Agile world. There are a lot of misconceptions about what agile is and what it isn’t…you should have a better understanding after you leave. We will cover a brief history of agile, discuss some of the most popular agile methods and techniques, and touch on implications to organizations.

Introduction to Scrum

Organizations are increasingly moving from traditional waterfall methods of software development to agile methodologies. Scrum has emerged as one of the most commonly applied agile practices. Today’s successful software projects implement at least some aspect of Scrum.

This presentation guides participants through every characteristic of Scrum, including roles, planning, artifacts, and most importantly, the motivation behind implementing these elements.

Agile Planning and Estimation

If things go according to plan, we estimate that by the end of this session you will have:

Written at least one user story
Broken down a user story by tasks and scenarios
Estimated effort using relative sizes and ideal hours
Planned for a release
Discussed why we estimate and why we plan

And we will have demonstrated how to:

Track planned work items and estimates using TFS
Use reporting in TFS to gain insight into the health of your project

Agile Adoption: Curing the Disease

Agile Software Development is not a process or a methodology, it’s a set of values and principles that requires years of thought, study, and practice to master; it’s a martial art. Often the cornerstone of Agile adoption strategies are technical practices or process changes that come from a book, and they’re expected to produce the dramatic changes promised by Agile proponents. Agile adoption is a long and difficult process that, to be most effective, requires significant change and reorientation of values throughout the organization.

That’s not to say Agile adoption is impossible. There’s no silver bullet or change of process that inspires instantaneous change in large, complex software organizations, but there are incremental and concrete changes that can be implemented to demonstrate Agile’s value proposition and provide evidence to support the superiority of the Agile approach. The slow, steady, and demonstrable path to agile adoption can produce better and more substantial change and a more sophisticated appreciation of agile, than a slash and burn approach.

Treatments Discussed:

Always gather and radiate data – As you progress along with Agile adoption, gather metrics and evidence to demonstrate your gains. Don’t hesitate to brag.
Invert your QA – Get QA involved in requirements analysis and specifications. Test cases make great requirements.
Make the team an atomic unit – Stop tracking progress person-by-person, deliverables are at a team level, and task assignments are the team’s responsibility. Take a chance on self-organization.
Add retrospectives – Continuous improvement is the cornerstone of good agile adoption. Don’t become complacent, and embrace every opinion
Add demos – Take the opportunity to show and brag on your progress. Encourage attendance from a wide range of people. Embrace visibility!
Create iterations and deliver software to production after each one – Frequent releases of quality software will add to your cred as a budding agile juggernaut and gets the team in the pattern of delivery, that’s a good pattern to be in.
Get a mentor – Experienced agile coaches and mentors have a wealth of experience related to agile adoption and how to overcome the hurdles you’ll face. Don’t be a hero, quality help will get you where you want to be, faster.

Workshop: eXtreme Programming in .NET/C#

The best way to learn is by doing. This workshop will create small XP pairs and run through the XP practices of user story creation, planning poker, pair programming, and test-driven development, all in one session! This session is an adaptation of a 3 hour XP workshop meant to give a quick survey of what to expect from an XP team. Please bring your laptop with a .NET development environment to this session if you want to be guaranteed full participation, because we’ll need at least one laptop per pair!

RESTful Services in .NET 4.0

RESTful services are an architectural paradigm for creating APIs and service oriented architectures. REST is based on the philosophy of the HTTP protocol and proponents laud the approach for its simplicity. .NET 4.0 features a series of new features in response to the growing popularity of RESTful services. This talk will give an overview of the RESTful approach, description of alternatives and tradeoffs, and a code-centric demonstration of .NET 4.0 and Visual Studio 2010 features to support REST.

Session Outline:

Overview of REST
RESTful Services in the wild
REST anti-patterns
REST vs SOAP
REST in .NET 4.0/Visual Studio 2010

Agile Team Dynamics Workshop

Is your agile team just going through the motions? You learned processes, and installed tools. What are you doing about individuals and interactions?

Through the Agile Team Workshop, you and your team will learn to:

Capitalize on individual strengths
Optimize roles and assignments
Communicate and collaborate
Attain peak performance
Enjoy working together

Identifying Waste and Amplifying Productivity: Lean and Agile

Lean/Agile–Maybe you’ve heard about it, read about it, or even tried it out. Maybe you don’t agree with every aspect of Lean/Agile software development, or you doubt that it will be the best fit for your particular project or organization. This seminar aims to dissect and de-mystify the process in an interactive experience comprised of lectures, candid discussions, exercises, demonstrations, and a few surprises. Come equipped with your specific situations and concerns about Lean/Agile adoption and software development processes in general. With your input, we will engage in a candid interchange with the goal of outlining a set of best practices and adoption techniques tailored to your individual situations.

Objectives:

Describe the core values
Define and describe terms and concepts
Distinguish between theory and actionable practices
Describe roles and responsibilities
Understand similarities and differences between various methods
Avoid common traps and pitfalls

The Rise of Acceptance Criteria

In this collaborative session, we will present a bit of theory and a bit of technology about requirements for agile development. For years User Stories have been a popular way to indicate requirements, but only recently have acceptance criteria emerged as important adornments to them. Come prepared to learn why, participate hands-on, and to see how TFS helps support User Stories and Acceptance Criteria to make agile Teams win.

Better Software Requirements through Mapmaking

The key ingredient to successfully developing quality software is communication. Through the years, lines in the sand have been drawn and battles have been fought over the appropriate forms and level of detail to use when documenting requirements specifications.

Describing the structure and behavior of a business domain is very closely aligned to the skills of successful mapmakers. Magellan, Vasco De Gama, and Columbus all demonstrated the value and usefulness of quality maps. While their stories about their travels were probably fascinating, the maps developed by their cartographers provided sustainable concrete records that were informative and helpful to others who followed.

As you navigate the treacherous waters of software development, quality maps can accelerate the journey and raise the quality of the results. In today’s information intense business world, there are limits to how much information can be communicated productively. Proper choices can lead to quality results, while poor choices can lead to disasters. There are a plethora of tools and techniques available to today’s business mapmakers. In this presentation, demonstrations and examples will be provided of a variety of techniques, along with a survey of popular tips and best practices.

ROI is Quality

What is Quality? What are its measures? When can and should it be measureable? We know that an agile project’s highest priority is to: “satisfy the customer through early and continuous delivery of valuable software”. We will explore when and where quality can begin to address the quantitative value of deliveries during the life of an agile project. Collaboratively working with the Product Owner to ensure that the Business Owners receive the value they expect.

Ambiguity is Good

Conventional wisdom says that ambiguity in requirements is bad. But in an agile project it is good, at least for a while and in the right measure. Come learn how your teams and your customers are ultimately better served by the right amount of ambiguity. Topics include the principle of delayed commitment, and how acceptance criteria fit in.

Introduction to Test Driven Development

Merely using an object-oriented language does not guarantee that the solutions you create are high-quality, flexible, and easy to maintain.

This presentation introduces the concepts of Test Driven Development (TDD) that allow us to create robust regression tests and good code. TDD is often mistaken for simply writing automated regression tests against an existing design. The deeper truth is that TDD is first and foremost about incrementally specifying, implementing, and improving your software’s design.

Behavior Driven Development/Test Driven Development

Test-driven development takes development to the next level by forcing a tight cycle of red-green-refactor. Behavior-driven development pushes the methods even further. It has been said that Behavior-driven development is test-driven development done correctly.

Making a Mockery of your Unit Tests

You’ve been hearing an awful lot about type mocking recently, but what is it, and why should you care? This presentation will answer these questions and is intended to serve as a primer to those interested. In order to further decrease the learning curve associated with this relatively new technique, a live demonstration will be given showcasing the latest version of Rhino Mocks, built specifically to take advantage of the .NET 3.5 framework. By the end of the presentation, you will understand how, through the use of mocking, you can potentially increase the consistency, integrity and speed of your unit tests dramatically.

Continuous Integration

When most people think of Continuous Integration (CI), they think of automatically compiling and unit testing their software on a central build server each time someone checks-in files to source control. We will go beyond the basics and discuss solutions to problems teams face when they start using CI. Our discussion will include CI best practices, what behaviors to avoid, and how to implement CI using Microsoft Team Foundation Server.

Refactoring in Real-Time

Patterns talks tend to be abstract, academic discussions rather than real world examples but not this talk. We’ll cover techniques you can use right now to refactor your current web application and implement a couple of patterns to create a more maintainable and testable code base. We’ll do all of this using an actual working web application – no “Hello World” garbage here!

Behavior-Driven Development in .NET

If you’re a TDD practitioner, you’ve potentially faced the problem of over-specifying or under-specifying behavior in your system under test. Too many tests can create waste and become a maintainability nightmare. Too few tests leave your system susceptible to quality and maintainability issues. This session assumes familiarity with Test-Driven Development and introduces developers to another way of writing tests in .NET using a behavior-driven style and tools like NSpec and NBehave.

Session Outline:

Review TDD and discuss potential frustrations
Introduce the BDD approach
Compare/contrast TDD and BDD styles
Introduce BDD tools
Demonstrate BDD tools on a simple problem

Naked Planning

Naked Planning is a project management methodology that focuses on value rather than cost and emphasizes continuous delivery over iterative development. To traditional agilists with years of experience in incremental development using Scrum or XP, some of the ideas in Naked Planning may seem heretical. The approach is built on lean principles of pull and flow and provides a flexible framework to allow a quality team to rapidly produce quality software.

Session Outline:

Cost-based planning vs. Value-based planning
Why estimates don’t matter
Lean concepts of pull and flow
Naked planning description
Naked planning demonstration

C# 4.0

The next version of C# contains a host of new features that will power the next generation of .NET applications. This session will be a code-centered demonstration of C# 4.0 features and how they might improve your next application.

Session Outline:

Introduction to C# 4
Dynamic languages and the dynamic keyword
Optional and named parameters
Covariance and contravariance

ASP.NET MVC

ASP.NET MVC is the newest way to build web-based applications on the .NET platform. This talk will explore the advantages of the MVC approach, how to build your first ASP.NET MVC application, and how to improve it through features from MVC Contrib and ASP.NET MVC 2.0.

Session Outline:

Introduction to MVC
Demo construction of a simple ASP.NET MVC application
Add components of MVC Contrib
Review and demo of ASP.NET MVC 2.0 features

Improving Personal Productivity

Personal productivity is out of scope in most agile discussions, but one of the most significant ways to improve the productivity of a team is to improve the productivity of its members. This talk will discuss ideas from GTD and productivity experts and investigate how these lessons can affect and improve the effectiveness of Agile teams.

Session Outline:

Factors that affect productivity
Introduction to GTD
Applying GTD concepts at the team level
Productivity Utopia

Making Productivity a Priority from President to Peon

As much as we learn and as hard as we try still many of our software projects fail. Hundreds or thousands of factors combine within a team or an organization to cause failure or inefficiency, but a large percentage of projects I’ve seen fail failed because of unproductive teams. Maybe they produced endless discussions or documentations instead of software, maybe they produced thousands of bugs instead the essential features, maybe they produced accusations and blame instead of working together toward a common goal, or maybe they didn’t produce much of anything because they weren’t motivated or didn’t know what they were supposed to build. Productivity in a software team is the team’s ability to produce quality, working software, but the concept is ubiquitous throughout all industries.

This session will address how everyone from the CEO to an entry-level developer can impact the productivity of their organization and the success of their software projects. We’ll look at how techniques from agile and scrum can help improve productivity of teams as well as how individuals, teams, and organizations can each learn productivity lessons from GTD and other non-software disciplines.

Continuous Testing in Java

Continuous testing promotes the idea that the best way to build better software is by getting feedback early and often. Using continuous testing you get instant feedback on the status of your tests right in your IDE. The earlier you can fix a bug, the less it costs, so why not just fix it right when you create it. The practice of continuous testing blurs the line between syntactic correctness and semantic correctness and helps you build quality code with confidence.

This session will introduce the concept of continuous testing and give examples of continuous testing in Java and .NET.

Easy OpenID For Your .NET Application

How many username and password combinations do you have to remember. Stop creating applications with their own authentication database. Stop making your users register for yet another account.

This session will give an introduction to OpenID, how it works, and the options that exist for creating an OpenID implementation. It will conclude with a demo of how to quickly include OpenID in a ASP.NET application that runs in medium trust.

Rapid Web Design with ASP.NET MVC and Castle ActiveRecord

So you’re writing your next application in ASP.NET MVC, why should you give up the elegance of ActiveRecord just because you’re not using Ruby on Rails?

This session will introduce the ActiveRecord pattern and take you through the construction of a web application using Castle ActiveRecord.

AgileDotNet 2010 Content

allen — Mon, 03 May 2010 20:34:42 +0000

On April 30, 2010 I did a couple of presentations at AgileDotNet 2010 in Dallas. Here are the slides and supporting code samples from those presentations.

Agile Adoption Strategies – Business/PM Track

Slides

ASP.NET MVC – Advanced Development Track

Slides

Code – Team Management App

Code – User Group CMS

Agile Marketing

allen — Thu, 12 Mar 2009 21:26:15 +0000

Our marketing team here at Improving uses Scrum on a daily basis. The team recently wrote an article about their progress. It’s an interesting read and reminds me to look around for ways to improve by noticing ideas and practices that help solve problems in other areas and disciplines.

I Love Evernote

allen — Tue, 03 Mar 2009 23:44:33 +0000

I’m now completely addicted to evernote. I’ve installed it several times but, until recently, never really used it. I always thought “what am i supposed to use this for?”. I guess I just didn’t get it. Well… now I do. I watched Merlin Mann’s desktop tour, and it convinced me to give it another shot. I’ve had DevonThink, Yojimbo, OneNote, and Evernote all installed, but never really used any of them.

I now dump almost everything into Evernote. I used to use Stickies, random disorganized text files, notes in the margins of notebooks, and half a dozen other tools to record random bits of data. Now, it all goes in Evernote. It’s the bag for all the stuff that has no place.

Evernote is indexed (even uses OCR for text in images), allows tagging in multiple notebooks, syncs to the web and iPhone, and has, I’m sure, dozens of other awesome features I haven’t even used yet. It supports audio notes, which has helped me get my SpeakEasy and old Outlook recordings catalogued for the sake of having a “SINGLE” repository for all of my keepsake junk. I can only imagine the possibilities for how this will help me organize the random emails i’ve sent to myself and all the other inaccessible and redundant pieces of data I have lying about. It is changing the way I use my computer and how I see and organize data.

Evernote even inspired me to start using 1Password for all my password archives. Evernote doesn’t really do this well yet, but 1password is working out great. I used to have passwords listed in plain text in text files in a notes directory on my computer. Since the notes directory is becoming history (all bit by bit getting merged into Evernote), I had to put the passwords somewhere, and it’s a load off my mind having them somewhere secure and available on all my computers and iPhone. 1Password’s browser integration is freakin awesome (it used to annoy me, but now I love it, I guess I just had to submit to the tool .

Evernote and 1Password have now joined Quicksilver, Path Finder, Text Mate, Cyberduck, OmniFocus, vmware Fusion, and Sound Source as my must have Mac applications. There’s currently no Quicksilver plugin for Evernote, but there is a useful applescript for quick note entries. The applescript tool is still not as functional as the (awesome) Quicksilver text file manipulation actions (my former primary notekeeping tool), but maybe it will convince me to investigate Quicksilver’s plugin architecture and try to implement it myself.

Thumbs up evernote for the great work (and for being free so that stubborn people like me will actually use it .