# Friday, August 21, 2009

Episode 42

The 2009 Lansing Day of .Net was held August 1 at the Jack Breslin Student Events Center in East Lansing, MI. This was the first event that Dennis Burton organized and he discussed it with us here.

8 mins, 28 secs

Friday, August 21, 2009 5:16:31 AM (GMT Daylight Time, UTC+01:00)

I will be presenting "An Introduction To Object Oriented Programming" at the Findlay Area .Net User Group August 25 (next Tuesday) in Findlay, OH. For more information visit the group's web site at http://fanug.org

This is actually my second time speaking at this group but it's the first time since 2002, so they have probably forgotten.

If you are in Northwest Ohio or central west Ohio, please come.

Friday, August 21, 2009 1:52:59 AM (GMT Daylight Time, UTC+01:00)
# Wednesday, August 19, 2009

Episode 41

Sara Ford is the Program Manager for Microsoft's CodePlex site. In this interview, she discusses the CodePlex site, open source software, and what she has in common with an Apollo astronaut.

19 mins, 50 secs
Wednesday, August 19, 2009 6:05:54 AM (GMT Daylight Time, UTC+01:00)
# Tuesday, August 18, 2009

John Kellar stood on stage in the final minutes of the DevLink closing ceremonies, gazing across the audience and smiling. In front of him, someone was introducing the members of the staff that had helped him organize and execute the conference. Behind me, the applause began. A few people in the back stood and clapped; then two more in front stood up; then I stood and applauded; soon, the entire auditorium was on its feet, cheering those who had put together an amazing conference.

John said he wanted to focus on the entire conference experience to make it worthwhile for the attendees. He succeeded at an amazing level.

Here are some highlights from my experience at DevLink 2009

'Configuration Management with Team Foundation Server' presented by Steve Andrews
The first day, all sessions were three hours long. Steve Andrews showed how to configure the automated build settings in TFS. He dug deep into the details of TFS and showed the various options available for continuous integration and how to customize the process.

'Good ways to use Live Mesh' Open Space
I called this session because I wanted to use Live Mesh as my backup strategy, easing my angst about rebuilding a laptop or PC. Jeff Blankenberg showed me the details of this very cool technology, answering all my questions and showing how he used Mesh to backup and share files.  Others looked over our shoulder as he did so, making this a successful Open Space for several people.

'MEF' Open Space
I have been delivering a talk on Managed Extensibility Framework (MEF) for almost year. But in this session, I got to ask questions of Kathleen Dollard, who has been working with this framework on a production application and has some very definite ideas about the future of MEF. It’s startling to me how much I learned during this hour.

'Enhance your .NET Application with SSRS' presented by Jessica Moss
Jessica had some hardware issues in this session, but recovered well enough to put on a solid presentation. I was glad to see because I have a customer looking for a class on SSRS and she looks like a good candidate for that.

'Dot Net Rocks' panel discussion
Prior to the closing ceremonies, Carl Franklin and Richard Campbell recorded an episode of their popular Dot Net Rocks podcast. A panel consisting of Josh Holmes, Jim Holmes, Kathleen Dollard and Billy Hollis discussed whether software development was becoming too complex. It wasn't one of Franklin and Campbell's best shows, but it was fun to watch them perform live.

Conferences are a chance to meet up with old friends, meet new friends and exchange ideas. DevLink was particularly good for this because so many people attended from outside my geographic region. The usual suspects from Michigan and Ohio were there, but I spoke with people from Atlanta, Virginia, Colorado, Canada and Great Britain.  Hallway conversations were as good as any I’ve had at a conference.  We were even able to meet in a more relaxed atmosphere at several organized evening events. The 3-day format made it possible to establish relationships with people through multiple conversations. John Kellar reminded me that this is not an accident and it's the reason the word "Link" appears in the conference name.

Technology and Friends
I recorded thirteen interviews for my show at this conference. I've already released one episode and cannot wait to produce and share the rest.

This was the best-run community conference I have attended to date. From the time I woke up to the time I went to bed, there was not a minute that I lacked something to do and learn. Often I had to choose between two or three options. I am already looking forward to next year.

DevLink web site

Tuesday, August 18, 2009 1:22:12 PM (GMT Daylight Time, UTC+01:00)
# Monday, August 17, 2009

Episode 40

On the third and final day of DevLink 2009, John Kellar sat down and talked about the planning and work that went into the conference; what the conference accomplished; and what it meant to the developer community.

13 mins, 35 secs

Monday, August 17, 2009 1:14:34 PM (GMT Daylight Time, UTC+01:00)
# Sunday, August 9, 2009

A year ago, I was surprised to find myself on a bus rolling toward Tennessee.  Although I had made it a habit of attending as many community events in the area as I could, Tennessee seemed too far to travel for a conference. So I originally balked at the idea of going all the way to Murfreesboro, TN for the DevLink conference.

Matt B But I found myself between jobs last August and I decided I needed to use this free time to network with others in the IT industry.  So, at the eleventh hour, I found an unused ticket; reserved a hotel room; and signed up for the community bus ride from Michigan to Tennessee.

For so many reasons, going to DevLink turned out to be the right decision.  I saw some very good sessions (Joe Wirtley's WPF presentation remains one of the best I've seen on the topic) and I got my first real taste of open spaces done well. But, more importantly, I met so many passionate people from the developer community. Looking back, it's startling to me how close I've become with some of them in just a few months.

This was one of the events that triggered for me an intense involvement in the developer community.  Since returning from DevLink, I've spoken at numerous user groups and conferences; I've become an officer for a local .Net user group; I've blogged with a vengeance; and I've become one of those loud opinionated guys you see on Twitter and at local events.

I won't say that DevLink is solely responsible for my community involvement over the past year. But I definitely found inspiration in the passion folks I saw there.

Carl F and Matt C This year, I'm planning a return trip to DevLink. The speaker lineup and the agenda look amazing; the event has expanded to three days and moved from Murfreesboro to Nashville; and the Open Spaces area promises to provide more stimulating discussion.

I spent most of my time at the 2008 DevLink in the Open Spaces area, but this time, I plan to attend more sessions. I'll also bring my still camera to capture the faces of the attendees and I'll bring my video camera to capture fresh ideas from passionate developers for my Technology and Friends show.

I hope to reconnect with many in the developer community and meet new people there. If you see me at DevLink - even if we haven't met before - please approach me and say "Hello". I'm looking forward to talking with you.

Sunday, August 9, 2009 9:56:57 PM (GMT Daylight Time, UTC+01:00)
# Saturday, August 8, 2009

Cliff Atkinson's Beyond Bullet Points proposes a radically new approach to creating presentations based on Microsoft Power Point.

Atkinson provides a template (available for download); an outline that splits a presentation into lengths of 5, 15 and 45 minutes; and an abundance of advice on improving your presentations.

After reading the book, I discarded the template and the outline but I embraced many of his ideas.

Here is some of the book's best advice:

Allow your presentation to tell a story.
The first presentation I did after reading this book included a story about consultants Juan and Amal, who had nearly identical skills and accomplishments but received very different performance reviews. Most of my presentations are instructions on how to use software, which doesn't lend itself well to a story format. If possible, however, I try to weave a story into the presentation.

Minimize the text in your slides.
Atkinson recommends eliminating all bullet points from every slide. The only text on each slide should be a headline. I haven't gone that far, but I have drastically reduced the amount of text on each slide. When I open an existing deck, I move much of the slide text into the Notes section. This simplifies the presentation, but keeps the text with the slides when I distribute them to users. During presentation, I make the former bullet points part of my verbal presentation, rather than something the audience reads off the screen. This keeps the audience's focus on me, rather than on the screen.

Use simple graphics
A simple graphic communicates an idea visually. I have been replacing the bullet points in my slides with a headline and a single photograph that relates to the slide topic. The slides become more interesting but less distracting.

Rehearse your talk
I already knew this but the book's reinforcement helped remind me how important it is to be familiar with one's material. Nothing achieves this goal like a couple dry runs through your presentation. Ideally this should be in front of other people (to provide feedback) and in a room similar to the one in which you will be presenting; however, filming your presentation and reviewing it yourself is also very helpful.

I have not bought entirely into the Beyond Bullet Points approach. But I have internalized many of the ideas in this book and my presentations have improved as a result.

Link: Beyond Bullet Points Online

Saturday, August 8, 2009 11:21:54 AM (GMT Daylight Time, UTC+01:00)
# Friday, August 7, 2009

Lynnne Truss is a stickler - a stickler for proper punctuation. 

I don't know if she wanders the streets with a marker to add missing apostrophes - such as on posters for the movie Two Weeks Notice; or with white stickers to conceal extraneous punctuation - such as in a store signs that read "Boat Motor's", but I know that she is tempted to do so. I know that it pains her to see such misuse of common punctuation in public places. She agonizes each time she sees "its" and "it's" misused.

She put together "Eats, Shoots & Leaves" - a small volume designed to clarify the proper usage of punctuation in the English language and to pursuade us that it is important. 

Like Ms. Truss, I agree on the importance of punctuation, particularly in public or professional communication; but I don't always know the correct rules, so her advice is useful.

The book devotes a full chapter to the use and abuse of the apostrophe; another to the comma; a third to the dash; and so on. For each punctuation mark in question, Ms. Truss lists the proper usages of that punctuation and some common, and annoying, violations of those rules.  For example, her book lists 17 distinct uses for the comma.

It’s a difficult task because punctuation rules are sometimes vague and open to interpretation; and because the rules are often broken by respected writers; and because the rules change in a living language like English. 

But Truss does her best to clarify the vagaries and to evangelize the static, unambiguous rules. It's important because the meaning of a sentence can change dramatically, depending on the punctuation: "Extra-marital sex" does not mean the same as "Extra marital sex";

The poor punctuation of "Eats, Shoots & leaves" (the title; not the book) misrepresents the characteristics of a panda. An extraneous comma suggests that a panda employs firearms after its meal and before its exit. Correctly punctuated ("Eats shoots and leaves"), the phrase describes a panda's favorite meal.

Most of Ms. Truss's advice does not sound like a textbook. Regarding comma usage, for example, she dictates the rule: "Don't use commas like a stupid person". What she means is that one should step back and read a sentence to verify that the punctuation conveys the correct meaning. 
For example, the sentence
"Leonora walked on her head, a little higher than usual."
is grammatically correct, but probably not what the author intended.

Despite her passion for the topic, her style is light and engaging. I laughed out loud several times while reading this short volume. She parenthetically refers to Gertrude Stein as a "strange woman" (presumably because she disagrees with nearly every opinion Ms. Stein holds on punctuation); and she once described a long, over-punctuated sentence as exhaustedly slipping into a comma.

I really enjoyed this book and will keep it on my bookshelf beside Strunk and White's excellent The Elements of Style because it is concise, accessible and extremely useful.

Friday, August 7, 2009 12:37:50 PM (GMT Daylight Time, UTC+01:00)

Back To Basics

This series of articles provides an introduction to the concepts used in Object Oriented Prorgramming and OOP code samples in C#.

Part 1: What is OOP?

Part 2: Understanding Objects

Part 3: Object Oriented concepts


Friday, August 7, 2009 3:15:45 AM (GMT Daylight Time, UTC+01:00)
# Thursday, August 6, 2009

Back To Basics

In this section, we will discuss the key concepts important to Object Oriented Programming (OOP). An object-oriented system has the following characteristics

  • Inheritance
  • Polymorphism
  • Abstraction
  • Encapsulation
  • Decoupling

Some systems (and some languages) don’t fully support all the above constructs and still refer to themselves as “object-oriented”. This is a matter of some debate, but it is my opinion that a language or system must implement each of the above concepts in some way in order to be considered object oriented.


Inheritance is the ability to create a class based on an existing class. In this model, the existing class is known as the “parent class”, or “base class” and the new class is known as the “child class” or “derived class”. By default, a child class will inherit all properties and methods of its parent class.

In C#, we inherit a class from a parent class by appending a colon and the name of the parent class to the child class definition, as in the following example:

public void ChildClass : ParentClass {} 

Marking a method as virtual in a parent class allows it to be overridden in a child class. This means that the method can be replaced in the child class with new code.

public virtual Int32 DoMath (Int32 num1, Int32 num2) 
  return num1 + num2; 

We can then use the “override” keyword in the child class’s method to replace the code in the parent’s class method, as shown below

public override Int32 DoMath (Int32 num1, Int32 num2) 
  return num1 - num2; 

It is possible to have multiple child classes that inherit from the same parent class. In some languages (but not in C#), it is also possible for a child class to inherit from multiple parent classes.

As a general rule, if I find myself writing a lot of conditional logic in a class’s methods – depending on how the object is created or the environment, the class runs one of several blocks of code – I will consider refactoring that class into a number of subclasses. Each class will inherit from a common parent class but the conditional logic is eliminated because each subclass contains only the code relevant to how it is created.

Interface Inheritance

Inheriting from an interface is similar to inheriting from a class, except the parent class does not contain any implementation, so each subclass contains all method code it needs to run. This is useful if a set of subclasses need to share the same public members but do not have any code in common. Interfaces also have the advantage that a single class can inherit from more than one interface.


Earlier, we said that objects communicate by passing messages via their public interface.

Polymorphism is the ability for different objects to respond to the same messages in a different, but appropriate, way. In OOP, this is done using inheritance. Because a child class inherits properties, fields and methods from a parent class, we can have several different child classes sharing the same public members. Each of these classes would therefore accept the same message types. However, each base class may override some of the behavior of the base class and may do so in a way appropriate to itself.

For example, we may create a Vehicle class that has a method Drive() that accepts no parameters.

We can derive two child classes - Car and Airplane - from Vehicle and they will each inherit the Drive method. But driving a car is not like driving an airplane, so each of these methods would be overridden and the overridden child methods would be very different from one another. Calling the Car’s Drive method would cause the axels to turn and rotate the four wheels beneath the car. Calling the Airplane’s Drive method would explode jet fuel and propel the airplane through the sky at a high velocity.

This is an example of two objects (Car and Airplane) that accept the same message (Drive) and respond differently but appropriately.

The C# code for this set of classes would look similar to the following

public class Vehicle 
  public virtual void Drive() 

public class Automobile: Vehicle 
  public override void Drive() 
    Console.WriteLine(“Turn axel and wheels and tires…”); 

public class Airplane: Vehicle 
  public override void Drive() 
    Console.WriteLine(“Explode jet fuel and propel through the air…”); 

The picture below shows the hierarchy of classes that inherit from a single parent class.


Abstraction is the process of simplifying an object or system by focusing only on those parts of the system relevant to the current problem. In OOP, abstraction is typically implemented using encapsulation.


Encapsulation hides implementation details of an object from that outside world. Again, this goes back to our goal of decreasing complexity. We don’t need to understand all the workings of an object in order to use it. Returning to our Automobile example, in order to start a car, I need only know to put the key into the ignition and turn it for a short time. A lot happens inside the car (gasoline is injected, battery is engaged, sparks fly, gas explodes) but I don’t need to the details of any of that in order to start the car. In fact, it’s easier for me to focus on starting the car if I ignore the other things going on within the automobile.


Finally, decoupling is a key point of object oriented programming that simplifies a system. In a decoupled system, the dependencies between objects are minimized. Encapsulation helps with this because external objects cannot change the internal attributes of an object if they cannot access it.

However, the responsibility for decoupling ultimately rests with the developer. Use messages to communicate between objects and maintain as little state as possible. Expose only those attributes needed by others and avoid coding side effects in your object’s methods.

In my experience, decoupling is the OOP concept that is ignored the most by people trying to build object oriented systems.


As we stated in part 1 of this series, the goal of Object Oriented Programming is to manage complexity. We do this by modeling our application as many people see their real world systems – as a set of loosely coupled objects that interact with one another. This helps us to split a complex problem into a number of more manageable objects. It also allows us to simplify the management of those objects by encapsulating complexity, maximizing flexibility through inheritance, and keeping the objects independent of one another.

Thanks to Chris Woodruff, who contributed to this article.

Thursday, August 6, 2009 12:53:29 PM (GMT Daylight Time, UTC+01:00)