# Friday, April 22, 2011

Yesterday Joel and I did our “Agile Buffet Table” session at GIDS in Bangalore, India.

We talked about XP, Scrum, and Kanban and how you can build your own methodology by mixing and matching the features from each of these agile brands. We had *great* audience interaction, the best I have ever had in India. We wrapped up the session by opening Excel and designing a unique process with the audience. Our exit was also very funny, there was no break between sessions(!), so the next speakers came in and were ready to start when we ended. So I impersonated the next speaker, very agile. Winking smile

The slides are available here (via slideshare.) In addition we talked about a lot and have recommended the following resources:

Also had some books to take a look at, they came up at various points in the discussion, check out any one of them:

posted on Friday, April 22, 2011 10:54:04 PM (Eastern Daylight Time, UTC-04:00)  #    Comments [2] Trackback
# Thursday, April 14, 2011

Next week I will be speaking at the 4th Great Indian Developer Summit (GIDS) in Bangalore, India. I have spoken at the last three GIDS and really enjoy the “ninja” speaking style: 50 minute sessions! So my technical sessions will be all code/demo, no slides, only the “please fill out the evaluation” slide at the end. Here are my sessions:

Tuesday April 19th, .NET day:

  • Building RESTful Applications with the Open Data Protocol (no slides!)
  • Agile Estimation (ok, slides for this one)
  • Enhancing Developer Productivity across the Entire Stack (Telerik vendor session, NO SLIDES, no marketing, just code!)

Wednesday April 20th, Web day:

  • Introduction to WCF RIA Services for Silverlight 4 Developers (no slides!)

Friday April 22nd, Seminar day:

  • The Agile Buffet Table (with Joel) Ok, this session will have slides, but last year it was standing room only, we got in trouble with a fire hazard, so get there early.

Visit Telerik, get free goodies, win stuff and come to our party!

GIDS is four years old and Telerik has been at each and every GIDS since its inception. On .NET day (Tuesday), we are handing out some great free goodies at our booth, so make sure you stop by before the keynotes before it gets mobbed. (Last year our Tee shirts were in such demand, the booth got knocked over in a rush!) Also look in your conference bag for some other great goodies.

We have some great prizes, but another reason to come visit our booth is that in partnership with Pluralsight, we are throwing a great party on Tuesday night. (If you went to our party last year, you know what I am talking about!) Swing by our booth for a demo, some goodies, and tickets to our party. Space is limited, so come by early!!!

See you in Bangalore. Bring your umbrella, hopefully the monsoon is not as bad as last year. Winking smile

posted on Thursday, April 14, 2011 8:47:24 AM (Eastern Daylight Time, UTC-04:00)  #    Comments [2] Trackback
# Monday, April 11, 2011

Thursday, April 21, 2011
Learning MVC for the Web Forms Developer

Subject:
You must register athttps://www.clicktoattend.com/invitation.aspx?code=154501 in order to be admitted to the building and attend.
The biggest problem for developers moving to MVC is not being able to use a lot of the Web Forms knowledge we've already spent so much time learning. This presentation will take the developer from something they already know - Asp.Net Web Forms and move them into MVC utilizing the knowledge they already have for Web Forms. We will review a complete ASP.Net Web Forms application where we do common tasks, and then see how to do the equivalent type of task in MVC. Procedures such as Data Binding, Error Handling, URL routing, AJAX, and more will be covered. No MVC talk would be complete without discussing how to unit test our MVC code as well. This discussion will also cover common controls (grids, etc) available to the developer and how client libraries used to enhance our MVC applications.

Speaker:
Adam Tuliper, Cegedim
Adam has been developing software for over 15 years. He started his work in security and reverse engineering (x86 based - pre .NET) with the direction of going into the software protection and anti-piracy field. This gave him a foundation for learning the internals of other technologies from Win32 systems to CLR systems. Besides development, he has performed security audits and penetration testing for large and small companies alike. Adam currently works as a Software Architect for Cegedim. He has been deeply involved in .Net internals since early beta and currently works extensively with WCF, ASP.Net, SQL Server, MVC, C#, jQuery, and Silverlight.

Date:
Thursday, April 21, 2011

Time:
Reception 6:00 PM , Program 6:15 PM

Location: 
Microsoft , 1290 Avenue of the Americas (the AXA building - bet. 51st/52nd Sts.) , 6th floor

Directions:
B/D/F/V to 47th-50th Sts./Rockefeller Ctr
1 to 50th St./Bway
N/R/W to 49th St./7th Ave.

posted on Monday, April 11, 2011 10:43:43 PM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] Trackback
# Friday, April 01, 2011

See also:

·         Part I: How I started to use Scrum

·         Part II: Scrum, but

·         Part III:  Moving away from Scrum

In Part I we looked at how I got into Agile and Scrum. In Part II we explored how Scrum failed to be flexible enough to fit into my unique process. In Part III we took a look at how I got introduced to Kanban, without even knowing it. Today we’ll take a quick look at what Kanban is.

Kanban is a Japanese word that loosely translated means “signal card.”  Kanban’s underlying thesis is that by using signal cards at various points in the production process to indicate the amount of work completed, you can limit the amount of work in progress (WIP) and thus keep the system very “lean” and agile. Work in Progress (WIP) represents inventory and inventory is expensive to keep.

Kanban was originally developed at Toyota as part of the Lean manufacturing movement to facilitate pull systems in a just in time (JIT) production manufacturing process. Work is pulled through the system in single units by demand, instead of pushed in batches. Think Dell computer’s JIT assembly of your laptop as you order it; Dell is pulling a single unit through its production process on demand as opposed to pushing through a batch of computers and selling them pre-configured.

Over the past few years there have been several blogs and books describing a Kanban process as an agile methodology for software development.  There are far more robust explanations of Kanban out there on the Internet, so I will not try to outdo them here, however, let me give a brief overview and then circle back to the system I described in Part III.

As a development methodology, Kanban is an evolutionary process that focuses on the flow of work in progress. Individual items of near equal size are pulled on demand through the system. Kanban focus on the flow of the work, trying to make constant improvements to the flow.  This increases the predictability of the system. Evolutionary by nature, Kanban is designed to facilitate continuous learning and improvement to the process (the Japanese call this kaizen ).  Kanban teams usually put up a “Kanban Board” where they have the process states as columns and sticky notes representing the queue or work items and where they are in the production cycle. This visualizes the production system and allows you to spot areas for improvement.

clip_image001

The Kanban board is the most important item in the system, it represents the production flow. As an item moves from “design” to “development” to “test” and off the board to production, you can get a holistic view of the process and identify bottlenecks. Kanban has a daily standup meeting, not to focus on “what you have done today” since that is obvious via the Kanban board, but rather to focus on the production process and talk about bottlenecks and how to improve them.  For example if you have way too many items queued up in the “tester” queue, you can make changes to the way the work flows through the system (or identify that you need more testers.)

Kanban throws away the concept of a sprint and even estimation  to a lesser degree. Stories are larger in length and scope but you have less of them in your system. If you break down tasks into digestible units of comparable size, by looking at the Kanban board, you know how long it typically takes to get tasks done.  The goal of Kanban is to keep the work in progress as small as possible, at the exact flow rate that the team can handle.  The team will commit to deliver work items at the flow rate, and expedite important work items. As time progresses and the team improves, the flow rates can be adjusted.

Sound familiar? This is the system I stumbled across at my start-up defined in Part III (minus the Kanban board.)  If I had a Kanban board I would have had all of the states (analysis and rules complete, in progress,  etc) on top and had sticky note for each task (the RegEx work) in the workflow and where it was in the process. Since our tasks typically only took half a day and moved from start to finish off the board in about 48 hours and we had a remote team, it would have made sense to have an electronic board. Nonetheless, our quazi-Kanban system limited work in progress, allowed the developers to pull work out of the queue in a very predictable pattern, and produced quality results. The most important part is that the system was flexible.

Since we started as a Scrum process and evolved to a more lean manufacturing influenced production system, I learned that no single development process (such as Scrum) is a “silver bullet”.  I also realized that all of the “features” of Agile are available to you and you can mix and match them-as long as you adhere to the Agile values put forth in the Agile manifesto.  More on this later in the last part of this series.

posted on Friday, April 01, 2011 10:02:49 AM (Eastern Daylight Time, UTC-04:00)  #    Comments [0] Trackback