The trouble with project managers

As an engineer, I’ve always had a love/hate relationship with project managers. On one hand, they’ve historically been the first (and most difficult) roadblock to me making the “right” changes to a system. On the other hand, they’ve typically been there to provide valuable insight that guides and shapes the systems I’ve worked on. For a while I wondered what life would be like without a project manager. I would be free to run at the things I thought were most valuable and implement them correctly while making my own time-to-market considerations. I wouldn’t have to spend countless hours in meetings discussing how I planned on implementing something and why it was the right thing to do to someone who didn’t fully understand what I was saying and mostly heard me asking for more time and more resources for less features. It sounded ideal.

Advertisement

Let’s Play Bizio: Developer Edition 01

It’s been a long time coming but I’ve finally recorded the first demo of Bizio. In this half-hour special we’ll start a company with Will Smith, tackle an easy portfolio project, hire some employees, slash salaries, and so much more. Take a look, leave some comments, and get pumped because Bizio is moving along. I’ll continue producing videos more regularly to cover particular features as they are added and in a while we’ll do another playtesting demo. Enjoy!

Bizio Update 3: AI and Turn Actions

AI is such a broad term these days, but in Bizio it directly refers to the decision-making logic implemented for the non-human players in a game. You first need to understand the mechanics of a turn before you can understand how the AI leverages these mechanics to make decisions like a real human.

Bizio Update 2: Project Management

At this point in the project you might expect that things are organized, documented, and that we have a clear roadmap to completion. Unfortunately that is not the case, but it’s never too late to make a change for the better!

Bizio Update 1

Hey! The first update on the development progress for Bizio obviously can’t cover everything I’ve done up to this point but over time I’ll cover a majority of the functionality and inner workings.

Some Linq Tips

Since its introduction alongside Visual Studio 2008, Linq has made many common programming efforts a breeze. As it has developed, Linq has become a powerful tool for interacting with SQL, Xml, and many other datasources. Developers that are familiar with the structures commonly found in a query language will feel at home using Linq in their code, and those who are less query-savvy will learn to appreciate the features that are introduced with Linq.
 
The purpose of this article, however, is to talk about Linq beyond the 101-level course. Linq is incredibly convenient and also introduces a few other programming concepts that can be applied elsewhere. This article will talk about some less well known extensions as well as the programming mechanisms used to take advantage of them. Here are a few of the things I’d like to cover:
 

• Count, Any, and All
• SelectMany
• Single/SingleOrDefault
• Zip

A Robust INotifyPropertyChanged Implementation

Today I’d like to share with you one of my most valued base classes when developing a WPF or WinRT application. Given that WPF applications are intrinsically designed to work well with the MVVM pattern (or perhaps the other way around) it should come as no surprise that every project that implements this pattern has some implementation of the INotifyPropertyChanged interface. I’ve seen a few different variations (all generally very simple) and, in this article, I’d like to present my latest iteration on this crucial base class. Let’s first start by identifying the problems we are trying to solve.

 

• We need an implementation of the INotifyPropertyChanged interface to allow for data binding
• We need some safe and convenient syntax for calling the event handler for PropertyChanged
• We need to make this call thread safe
• We need to reduce the memory footprint of this call
• *BONUS* Can we factor a pattern out of our code?

Creating an Ideal Logging System

This is the first article I am writing and decided to tackle a fairly straightforward topic. Every application I’ve worked on that was larger than a proof-of-concept benefited from some form of logging. The problem always was one of the following:

• There was no logging system at all
• The logging system was cumbersome to actually use
• The logging system logged way too much information
• The logging system wasn’t used in the most critical areas

So the first point is going to be solved simply by reading this article. We are going to walk through creating a simple yet useful logging system that is extendible and solves the above problems. Without further ado, let’s begin!