Tuesday, March 13, 2012

Utah Code Camp Spring 2012 Slide Decks

I had the opportunity to speak at Utah Code Camp again (my fourth code camp presenting Fall 2011 Spring 2011 Fall 2010) which was a lot of fun. Not sure if I would do three presentations again, but it was a lot of fun and I met a lot of great people.

If you attended one of my sessions, please take a minute to rate the session at SpeakerRate (not official eval… please do that too):

Here are the slide decks. Contact me with any questions!

The Randori starter project is available at https://github.com/mdclement/NumbersToLcdRandoriBase

The Code Katas session was presented as two slide decks.  One with the introductory material and the other with the guided FizzBuzz kata.

The code base that I started from (tests and methods without implementation) is available at https://github.com/mdclement/Linq--from-the-inside--Presentation-Base

Friday, February 24, 2012

Expanding my Speaking Footprint in 2012

So one of the things that I plan to do more of this year is presenting at Code Camps and the like.  I’ve presented several times at Utah Code Camp (Spring 2011, Fall 2011), but want to expand my footprint.  So, I’m currently submitted to Boise Code Camp, Chicago Code Camp and MADExpo.  Over the next few weeks/months I’ll see how well my session topics are received outside of the Utah community.  I also plan to submit to Portland Code Camp and Agile Roots this year once their calls for speakers are open.

If you’ve attended (and hopefully enjoyed) previous sessions that I’ve presented, please rate me at http://speakerrate.com/mdclement

The topics that I’ve been submitting (and that I’ll be presenting at Utah Code Camp Spring 2012) are listed below along with the abstract.  I’m looking forward to an exciting year of meeting with developer communities both inside and outside of Utah!

Linq (From the Inside)

Knowing how to use Linq is useful if you're doing any coding using .NET 3.5 or newer.  But have you ever thought about what is going on "under the hood"?

Join us as we dive into the guts of Linq and implement Linq extension methods such as Where, Select, Any, All and Sum.  Not only is it interesting to see what's going on, it'll help you to build better code using Linq.

Code Katas: Practicing your Craft

One of the key values as part of the Software Craftsmanship movement is to be "skill-centric" and as part of that, practicing our skills as software developers is key! The Code Kata format is a coding exercise that is repeated and perfected. It provides one of many ways to practice the craft of software development. We'll discuss the Code Kata format, introduce a few katas and discuss some other practice formats.

I will be guiding the Kata in C# (no previous knowledge necessary though). As this is hands on, to take full advantage of the session have Visual Studio or SharpDevelop installed, NUnit installed (or via NuGet) and an integrated unit test runner (recommend Resharper or NCrunch for VS).

Randori: Group Practice

Looking for a new way to practice your craft? Randori provides a complementary way type of training when compared with katas.

Elements of Randori are: Pair Programming, Pair changes with mechanism (Time box, Ping Pong), Start from scratch, Use TDD, Everyone should be following, Pair should be explaining, Audience gives suggestions only with when Green

An example is at http://vimeo.com/2499540 . This is a hands on session!

Tuesday, January 31, 2012

But I really learned from writing: Quote of the Week

Note: Might be silly to call this a “quote of the week” given that it’s been years since I posted one but… oh well.

Heard this this morning on NPR from an interview with the composer Philip Glass:

What this amount of music has done for me is taught me how to write music. Oh, I had great teachers. Boulanger was one. Another was Ravi Shankar. And I went through the Juilliard process, and that was good, too. But I really learned from writing, which is how painters learn to paint, and writers learn to write, and how even dancers learn to dance. In a way, that's true. But what was the value of being so prolific? It's how I learned my trade.

Philip Glass from Philip Glass At 75: Listening With Heart, Not Intellect

What I heard in there is "But I really learned from writing, which is how painters learn to paint, and writers learn to write, and how even coders learn to code."

Tuesday, September 13, 2011

Utah Code Camp Fall 2011 Slide Decks

I had the opportunity to present at the Fall 2011 Utah Code Camp on September 10, 2001. I have uploaded my slides to Slideshare.
If you attended one or both of my sessions, please take a few minutes to evaluate the sessions at SpeakerRate.
On both of these presentations, you’ll be able to glean things more from the speaker notes than from the slides.  I plan on posting more on each of these subjects later.
The Code Katas session is divided into two slide decks; one for the session specific slides and another for the slides for the Bowling Game Kata in C#.

Tuesday, April 12, 2011

Utah Code Camp Spring 2011 Slide Decks

As I’m sure at some point they will not be available on the Utah Code Camp downloads page, I’ve gone ahead and posted my slide decks from my sessions on SlideShare.  They are not entirely comprehensible, especially the Rhino Mocks one since the majority of the time was spent in code.  I’ll get that posted soon as well.

Saturday, March 19, 2011

Lessons from Laser Tag: Metrics and Feedback Loops

Recently the Utah Development Center at Microsoft (where I work) had a “morale event” (I still think it’s funny that they explicitly call them that) where we visited a local laser tag place.  We played three times and each time I ended up in the middle of the pack (yeah, I’m not that good).  But I did see some interesting lessons that could be taken from the experience.  Here is one of those lessons.

After the first round, an interesting thing happened.  We each got a printed “score card” to tell us how we had done.  It had how many kills, how many timed you were killed, breakdown by opposition player (friendly fire was off), number of shots fired, accuracy percentage and some overall team stats.  The one additional number on the sheet was “rank”.  Being good little programmers/engineers, most of us started to try to reverse engineer the ranking algorithm.  It appeared to be surprisingly simple.  We were ranked by number of kills. (I don’t think this was confirmed, but we suspected that number of timed you were killed was used as a tie breaker.)

It was like the game totally changed.  Because it did.

Suddenly the feedback loop from the metrics used gave us this: Don’t worry about accuracy percentage, don’t worry about the number of times you get killed.  Kill the most people and you win. The only thing that matters to your rank is number of kills.  The next game the overall kill count went up significantly (about 20% increase).

Metrics have the tendency to focus us like this, which is super powerful.  But remember, with that great power comes great responsibility.  While many still played for “team pride”, for some people the individual ranking became the most important personal metric of success.  If you no longer care about the success of your team, the number of kills that you sustain no longer matters.  It is not a metric that you care about. All that matters is getting the most individual kills.

Choose the metrics that you use with care.

A recent real life example that I heard went something like this: The manager of a development group doing SINO (Scrum in name only) set a goal for the group that “this year, we’re going to get everything done that we commit to for a sprint done in that sprint.”  This is a well intentioned goal.  Basically do what you say you’re going to do.  BUT, if that is the metric used, what happens to the amount of work committed to in a given sprint?  In order to do well against the metric, the amount of work committed to drops (or estimates are WAY high).  Suddenly half way through a sprint (or less) the developers have completed the work that had been committed to.  All that matters is getting the work committed to done.

Some managers reaction would be to think, “Well, that didn’t work, lets add some more metrics to get what I want.  Let’s continue to try to control the system.”

That may or may not be the best approach.  Eventually you may end up with a system that is so bogged down with itself that no work actually gets done.

I’m not saying that metrics are bad.  They can be very, very good and are very, very powerful.  Just be sure that you’re using the right tool for the right job.  Don’t use a nail gun where the gentle tap of a hammer is the right thing.

Thursday, March 3, 2011

Prime Factors Kata in C#

I recently led a practice of the Prime Factors Kata in C# at the Utah Software Craftsmanship Group.  I couldn’t find a C# version, so I adapted the Java version that Uncle Bob posted back in 2005.  I’ve done a recording of me practicing the kata so that others can practice it.  I recorded it at a fairly high resolution (approximately 1920x1080) which means you’ll need to watch it on a screen around that size in order to make out the text in most cases… sorry, this is my first attempt at screen capture of a coding exercise… I’m sure I’ll get better with practice!

Enjoy!

Prime Factors Kata in C# from Mike Clement on Vimeo.

Original design by andrastudio
Blogger port by Blogger Templates