Guys, I have had a tough couple of weeks and frankly have not been able to nail down a single topic I've wanted to cover.  For today's show I'm going to key off of that and talk about a few things:

• Programmers who want the prestige of being a lead developer but not the responsibility
• Should programmers understand office politics?
• The dangers of ignoring the past
• The idea of "controlling one's emotions"

"Resume driven development" is a humorous and often derisive term for a certain style of programming and programmer.  It's a tempting trap to fall into, but in this episode I go into my experiences with these types of developers and their projects and why you should avoid the temptation of becoming one.

Junior developers.  We've all been one, and some of us still are.  In this episode, I talk about some of my experiences as and thoughts on junior developers, which ones make for good hires, and I also try to offer encouragement to any junior devs out there who feel down and out.

In many shops, you often have someone, typically a manager, who's in charge of what and programmers who are in charge of the how.  Is this a natural division of the work we do?  In this episode, I explore why I think the what and how aren't truly separable.

We've all heard the term "goldplating" in software development, but what exactly is it?  Who generates it, and why should it be avoided?  In this episode, I dig into both stakeholder and developer driven goldplating, why it's bad, and how to mitigate its effects.

The Agile revolution was supposed to bring us new abilities to adapt to change in software projects.  In many cases, Agile has delivered on that promise, but in many other cases, it can be just as inflexible as Waterfall.  In this episode, I examine one such scenario and give some advice for programmers who find themselves in it.

We've all had to work with difficult programmers, but every once in a while we come across someone who's so onerous that they negatively impact the entire shop.  Unfortunately, sometimes these people are also highly skilled in some key area of your organization.  Are such people worth dealing with their toxic personalities?  In this episode, I answer that question and offer insight from my own experiences with such developers.

Have you ever had to fix a bug in code that you didn't write?  Most programmers have.  A common thing I hear when this happens is for the developer to say, "That's not my code".  In this episode, I talk about how unhelpful that phrase is and why I dislike it so much, as well as offering guidance on what to do if you find yourself consistently fixing someone else's bugs.

Taking pride in the code we write is really important.  The best programmers treat it like a craft.  But how much pride is too much pride?  What happens when we find ourselves unwilling to admit when we're wrong?  In this episode, we explore these concepts and end with takeaways for dealing with our own emotions and other defensive developers.

Some developers get to work on new projects, others of us provide maintenance on existing applications.  Why do organizations separate the work like this?  What are the effects of doing so?  In this episode I dig into why some organizations separate greenfield from brownfield development and offer my perspective on that approach.