Ben Northrop

Decisions and software development


2017   #57 - Unclosed Loops and Developer Frustration: Why is it frustrating for developers to switch tasks mid-sprint? The Zeignarnik Effect is a cognitive bias that might explain. (1 comments)

   #56 - Batch Jobs in Clustered Environments: As much as we'd prefer to do everything in real time, there's often a need for batch processing. The question is, where do these go? (0 comments)

   #55 - Code Review Best Practices: In my opinion, code reviews are the "secret sauce" in a successful development process. Here are some best practices. (0 comments)

   #54 - Should I Care about the Alexa Platform? A Developer's View: In the past 6 months, Amazon is killing it with Alexa devices. Should developers jump on the bandwagon if they haven't already? (3 comments)

2016   #53 - Reflections of an 'Old Programmer': Framing our programming careers in terms of knowledge accumulation and decay can yield some interesting insights. (106 comments)

   #52 - The Agile Fantasy Draft: How does work get assigned on your team? A solution we've come up is the "fantasy draft", and it works pretty well. (4 comments)

   #51 - If you Speak Up, Speak First!: When a decision matters, it's important to be aware of cascades, both informational and reputational. (2 comments)

2015   #50 - Let's not be Slaves to Fashion: A standard theory of fashion states: people find ways to make themselves distinct in order to separate from the masses. How much of programming is fashion and how much function? (9 comments)

2014   #49 - The Siren Song of Automated UI Testing: Automated UI testing is not necessarily ineffective or a waste of time, but the promise land of easy, cheap, human quality testing via automation is a chimera. (14 comments)

2013   #48 - Code like a Champion Today: Do features in our physical environment affect the quality of our work? The science of psychological priming might suggest the answer is "yes". (2 comments)

   #47 - The 3 Motivational Forces of Developers: After 15 years in industry, I've come to realize that the most defining quality of a developer is his source of motivation. (26 comments)

   #46 - AI Challenge at the Summa Summit: At the Summa Summit this year, we tried out a new, hands-on coding activity that we dubbed 'Coding Spaces'. This is a recap of the AI Challenge I led. (0 comments)

   #45 - Expectations and the Endowment Effect: When setting expectations with the client, be aware of the endowment effect, which states that losses loom larger than gains. (2 comments)

   #44 - Consistency and Innovation: Pick One: When you find a better way of doing things in your code, what do you do? Use the new solution going forward, go back and refactor, or neither? (5 comments)

   #43 - Pair Programming - My Personal Nightmare: Pair Programming may work for some, but not for everyone (including me). Quality work can and is often done by people working quietly on their own. (79 comments)

   #42 - Keeping Code Clean with Cruft4J: I wrote a simple static code analysis tool which calculates how "crufty" Java code is, taking into account instances of complexity and copy-and paste. (0 comments)

2012   #41 - The User Interface and the Halo Effect: Understanding why minor user interface glitches carry such a high weight in terms of our customer's perception of quality. (23 comments)

   #40 - Velocity and Story Points - They don't add up!: I love the idea of velocity in theory, but in practice it's doomed to be dangerously inaccurate and imprecise on most every project. (10 comments)

   #39 - Time Zones and GWT's DateTimeFormat: A puzzler about GWT's DateTimeFormat and Time Zones - how tough could it be to display a birth date? (5 comments)

   #38 - 7 Tips for Exception Handling in GWT: There are a few tricks and gotchas that are important to be aware of when handling exceptions in GWT. (15 comments)

   #37 - Power Hour - an alternative to Pomodoro: Multi-tasking is the norm in most modern software development organizations, yet a number of studies have shown that it makes us much less effective. (0 comments)

   #36 - Usability Testing on Agile Projects (part 2): The second part of the series: how to perform the usability test and then use the results to affect change. (2 comments)

2011   #35 - Usability Testing on Agile Projects (part 1): Usability testing within agile projects from a project management perspective, describing how to estimate, prioritize, and "burn-down" the usability test. (0 comments)

   #34 - Getting Past the Deciders: Three tips for avoiding decision fatigue on enterprise software development projects. (5 comments)

   #33 - A Room Full of Techies: Understanding the phenomenon of group polarization in software development. (17 comments)

   #32 - 5 Tips for New Developers: A couple weeks ago, I came across a good post, "lessons for software industry novices", and it inspired me to add a few more just for the hell of it. (1 comments)

   #31 - Modeling Reference Data in the Application Tier: Designing data structures for reference data in the application tier can be tough, mostly because what we mean by "reference data" isn't always consistent. (6 comments)

   #30 - An Agile Dilemma - How to start the Sprint: Six strategies for jumping into the sprint, and getting started with your tasks. (7 comments)

   #29 - Developers - How do you manage your to-dos?: There are days when my brain is literally over-flowing with things I have to do, and around every corner lies something new. How do you manage it all? (2 comments)

   #28 - A pattern for GWT code splitting: A simple pattern using the GWT 2.1 MVP framework for implementing code splitting for optimization purposes. (5 comments)

   #27 - Structuring GWT modules for large applications: It's not always clear when designing GWT applications whether one, two, or more modules should be created. (17 comments)

2010   #26 - Parallel asynchronous calls in GWT: A pattern for making asynchronous calls in parallel using GWT. (20 comments)

   #25 - Beyond Role-Based Access Control: Most often authorization is managed via simple roles, but seldom does this meet all the requirements of the business. (1 comments)

   #24 - The Problems of Decentralized Authorization: The status quo for enterprise authorization, decentralization, is fraught with problems. There's a way out though! (0 comments)

   #23 - An Architect's Morality: What's the best path to good judgement for an architect - via experience or reasoning? (1 comments)

   #22 - Collective Code Ownership and Craftsmanship: Agile methodologies hinge on a model of collective code ownership. But does this allow for craftsmanship or pride of ownership? (1 comments)

   #21 - Keep it Simple!: Cognitive fluency is the theory that things that are easier to think about seem to be more true, intelligent, and likeable. What this means for programmers. (0 comments)

   #20 - Usability, RIA, and GWT - 6 Questions to Ask your Users: Before jumping in and developing applications with GWT, there are a few things you need to know from your users first. (5 comments)

2009   #19 - Using Code Metrics with Purpose: To glean any strategic benefit, code quality tools must be used with fore-thought. (0 comments)

   #18 - SOA and Authorization: What's so hard about it anyway?: As usual, the new SOA paradigm adds some new complexity to old problems, like Authorization. (5 comments)

   #17 - Anchors Away!: How can a developer communicate an honest, but high, estimate to management? Try the concept of an anchor, from behavioral economics. (21 comments)

   #16 - What is 'Good' Software Architecture?: Can "good" architecture be defined in purely pragmatic terms? If the system fulfills the needs of the person or organization who funds its existence, it's successful ipso facto! (7 comments)

   #15 - 6 Tips for Managing Property Files with Spring: Managing property files in an enterprise application is not always as easy as it would seem. (43 comments)

   #14 - SOA and the N + 1 Selects Problem: The classic N + 1 Selects problem rears its head in the new world of SOA. (10 comments)

2008   #13 - Building a Better Resume for Developers: The developer resume is broken. It's dense. It's long. It's static. I recently built something better - I hope! (9 comments)

   #12 - The Code Review Potluck: Fagan-style code reviews do work, but seldom do we have the time or discipline to actually do them regularly. There is another way. (4 comments)

   #11 - Does Programming to Interfaces Buy Us Anything?: Most often, coding to interfaces is just dogmatically applied, adding to code bloat and developer frustration and providing very little real value. (24 comments)

   #10 - Deliberative Development: Silo development has it's advantages, namely speed. But political philosophy's Deliberative Democracy has something to say about the negative consequences. (0 comments)

   #9 - 7 Strategies for Unit Testing DAOs and other Database Code: Creating repeatably passing unit tests for an enterprise application is hard work, mostly because of the reliance on volatile data. Here are 7 common approaches for testing database code. (12 comments)

   #8 - Politics and Programming: We as programmers have beliefs about software development. We as citizens have beliefs about government. Is there any connection or correspondance between the two? (0 comments)

   #7 - The Architect's Dilemma: There's a natural tension between the philosophies of up-front design (BDUF) and in-time design (YAGNI). Can decision trees help? (5 comments)

   #6 - Managing Code Quality with PMDReports: Introducing my pet project, PMDReports, for managing code quality. (2 comments)

2007   #5 - Why are our Programming Gods so Unkempt?: Does a theory of finite will-power say anything about our software Gods, or the environment we work within? (2 comments)

   #4 - Is it Irrational to Comment your Code?: We know we should comment code, but will we? Game Theory's Prisoner's Dilemma says, "probably not". (8 comments)

   #3 - Why Code Quality Tools Work: Using rational choice theory to explain why PMD, CheckStyle, and other code quality tools work in the real world. (1 comments)

2006   #2 - Starting a Design Patterns Discussion Group: Once upon a time, I started a design patterns discussion group to slog through that distinguished blue and white book that decorated my bookshelf. Here are my lessons learned. (0 comments)

   #1 - The Search for a Good UML Tool: When we want a UML tool, it's most often to help us either design, understand, or maintain. There are a lot of tools out there, and all are not created equal. (0 comments)

I believe that software development is fundamentally about making decisions, and so this is what I write about (mostly). I've been building software for about 20 years now, as a developer, tech lead, and architect. I have two degrees from Carnegie Mellon University, most recently one in philosophy (thesis here). I live in Pittsburgh, PA with my wife, 3 energetic boys, and dog. Subscribe here or write me at ben dot northrop at gmail dot com.