Resources

Programming

• Singletons are Pathological Liars by Miško Hevery
  • Miško Hevery runs through a typical new developer scenario to explain why Singletons and the Global State make an application brittle and hard to understand. He then shows a way of using the Dependency Injection design to make requirements intuitive and obvious just by looking at their signature. In learning to write easily testable code you also learn how to write great code.
  • Complimentary video versions: The Clean Code Talks - "Global State and Singletons" and The Clean Code Talks - Don't Look For Things!.
  • These also bring in the concept of "call graph" vs "create graph": Separating the factories/builders/DI logic from the Business Logic.
• The Joel Test: 12 Steps to Better Code by Joel Spolsky
  • Joel's blog has a lot of great gems on software development and management. One of my most relevant, when dealing with product or project managers, is How to be a program manager ("What else do you need? A tiara?").
  • I've followed Joel from back when he was just making FogBugz (they did a video on DVD of how they make their software). He's also something of a role model for me, being the only other gay software engineer I was aware of back in the day, and seemed to be fairly competent to boot.
• Soft Coding by Alex Papadimoulis
  • Not everything should be dynamic: Avoiding the Enterprise Rules Engines inception.
  • The Daily WTF also has archives of Bad Code™ and commentary to go with it. Early in my career it was a great morning palate cleanser when getting into the office.
• Beyond PEP 8 (Beyond Style Guides) by Raymond Hettinger, core developer of Python.
  • It takes more than coding standards to make good software. This talk focuses on why architecture, organization, and design patterns (pythonic vs non-pythonic) is so important and can make a huge difference on long-term maintainability of a project.
• Algorithms to Live By: The Computer Science of Human Decisions by Brian Christian and Tom Griffiths
  • For general human-relatable computer knowledge. It gives a very broad overview of many different types of algorithms and how we use or could use them in every day life, often without realizing it. I've listened to it on audio once and have recently started replaying it to refresh my memory of some of the methodologies discussed.
• All the Little Things by Sandi Metz
  • Provides good insight for wrangling large functionality into much more manageable chunks. It makes a few assumptions but the technical aspects are applicable to practically any programming language. Their video blurb does a better job of describing it:

    Theory tells us to build applications out of small, interchangeable objects but reality often supplies the exact opposite. Many apps contain huge classes of long methods and hair-raising conditionals; they're hard to understand, difficult to reuse and costly to change. This talk takes an ugly section of conditional code and converts it into a few simple objects. It bridges the gap between OO theory and practice and teaches straightforward strategies that all can use to improve their code.

A few of my own philosophies, in addition to the above, could be boiled down to:

• Duplicate code is better than a bad abstraction. It's okay to repeat code or values once or twice. You usually have to repeat yourself two or three times before you have enough data to know how things should be abstracted.
• Consistency is just as important as efficiency, and by default more so. Code that is consistent is easier to intentionally change. Try out new things in one small area, see if it feels right, then either switch the new code back or make your next task switching all the existing code over.
• Spend 10-20% of your work time on things you know will be important or useful to yourself or your team, even if management doesn't explicitly sanction it. This could be reading any of the above articles, staying up to date on the PHP Internals mailing list, writing a script to make resetting your local database easier, or finding a pain point in your development process and figuring out how to make it better.

Presentations

Consensus

Establishing consensus in decision-making processes as part of a team effort to move in the same direction or allow others to try new things.

Part of a presentation at a previous workplace.

Dependency Injection

Exploring the What, Why, and How of using a Dependency Injection design for everyone, not just frameworks or inversion of control containers.

Presented at the Seattle PHP User Group Meetup in June 2014.