On my last post I talked about the approach I’m taking towards testing candidates for development positions, which for me has been working like a charm yielding excellent assignments.

Today I’d like to discuss a tangent subject which I’ve been meaning to write about for a long time, that touches the seven characteristic of truly effective developers. Needless to say, this blog’s title is totally inspired by Stepeh R. Covey’s “The 7 Habits of Highly Effective People”.

So without further due, here they are.


 1 – Fear The Stagnation

Truly effective developers make learning a part of their work, constantly spending time learning new stuff. They keep tabs on any new technology or term they happen upon while reading or hearing an unfamiliar term during a meeting, and immediately add it to their “read list”. Then during spare time or at evening back at home they’d google those terms and even take some new technologies of interest for a spin.

 Fearing the stagnation is not about fear really (although stagnant developers should indeed fear being left behind or worse without a job), but rather about the insatiable urge to be on top of current technologies and familiarize with the tools of the trade, in order to make use of the right ones when needed.


2 – Be Lazy

 So when did being lazy become a positive trait you rightfully ask? well, imho when developers are lazy in the good sense of the word they devise practices that yes, make their lives easier, but also carry some very favorable side effects with tremendous benefits for the project.

 Some examples of what lazy developers do:

  • Refactor & Eliminate Code Duplication - because code duplication and non readable code are hard work to maintain.
  • Automate Repetitive Tasks (think ALM) - significantly reduce time spent on boring tasks, allowing more free time by the coffee machine. Needless to say, automation eliminates human errors and streamlines the application’s life cycle processes.
  • Write Robust Code - as no one (and especially the lazy) likes getting called up at night or over the weekend just because they didn’t cover that end condition or use case, they write robust code covering as many end conditions possible. Sleep is important for the lazy, you see.
  • Use Proper Logging – A sure way to significantly decrease nights spent at the office on a wild goose-bug chase.
  • System Configurations – Make the system easily configurable from the outside, so we won’t need to reopen the code every time some manager wants to fiddle with some values. “Hey, do it yourself dude, it’s in the config file!”

Bottom line: being lazy actually promotes good software practices, and surely there are many more examples we can come up with.


3 – Be Goal Oriented

As soon as a developer gets a new task or project, immediately his brain gets flooded with implementation aspects and technical details. The ability to hold that urge to delve into the technicalities and start coding right away takes practice, but is key factor to being a good developer.

Instead, good developers grow a better instinct: figure out first what the goal is. Thus they ask the client or team leader questions to make sure they understand what’re the underlying requirements and what is it that we’re really trying to achieve.

This focus on the “what” first before the “how” encompasses many important benefits including:

  • It ensures the developer understands what’s required from him/her, product-wise
  • Allows the developer to see the bigger picture, elevating the making of better technical decisions
  • Saves time & money by resolving potential issues long before they even occur, instead of bumping into them by surprise down the line
  • Forces the client / product manager to re-think their requests, and potentially revise them if required


4 – Be Boring

It is known that software developers are boring dudes by default, however in this context I’m referring to coding style. Here’s the point: boring developers are consistent, which means you know they’d will follow the project’s coding standards verbatim.

This includes the file naming conventions, comments, classes, methods etc – all of these are going to have same structure, indentation and parameters name conventions, which ultimately results in readable and maintainable code.

Oh, and you can bet on it that you won’t find any foolhardy code snippets like one-liner programs, excessive use of side effects otherwise code tricks that are “cool” but are non maintainable by anyone else.


5 – Stand on the Shoulders of Giants

Good developers do not need to use frameworks or packages, as they can whip up their own infrastructure themselves. Effective developers, on the other hand, will make use of the best framework and libraries they can get their hands on, leveraging them to their full extent.

By knowing which frameworks, modules, packages and any other reusable component exists out there that can be put to use for the sake of the project at hand, great software developers are highly effective in their work as they focus on the core business logic instead of writing boilerplate code, they spare themselves from the headaches of re-inventing wheels while enjoying proven and tested components.


6 – Don’t Get Hung On Technologies

Technologies are a trend, they come and go like fashion, some step into the limelight for a brief while others prevail and stay around for years. Effective developers make it a habit not to get attached specific technology and will happily let one go in favor of a newer or better one, whatever promotes work better.

Instead of technologies, effective developers attach to the underlying principles, concepts, design patterns and best practices that are generic by nature in the sense that they’re shared across different programming languages, technologies, vendors and frameworks.

Thus, such developers are somewhat “technology agnostic” and can easily switch from using one framework or even programming language to another, sometimes just in a matter of hours, simply by leveraging their transferable skills.


7 – DDD (Defensive Driven Design) *

 * Heck, I think I just coined this new term

“If builders built houses the way programmers built programs, the first woodpecker to come along would destroy civilization” (Gerald Weinberg).

Funny but true, writing bugless software is close to impossible. However by writing defensive software and using proper testing mechanisms, effective developers can produce systems with a significantly low bugs per lines of code ratio. How? by employing the following principles:

  • Write Less Code - a very simple principle that says “less code = less bugs”. Easy to do by understanding and making proper use of components, packages and frameworks’ features instead of re-inventing wheels.
  • Think Edge-Cases – This principle is very similar to TDD: start by mapping as many edge cases as possible, then apply proper handling for each of these cases in your code.
  • Validate Code Examples - All developers love plucking a nice code example from StackOverflow and plugging it into their code. Effective developers take another step here and review each line, clean up and refactor the snippet before making it their own, thus making sure it adheres to the project’s code styling and quality standards.
  • “None Shall Pass” - strict validation of our system’s external interfaces and early dropping of invalid / improperly structured requests is also an excellent practice that effective developers use to increase the system’s rigidness.
  • Error & Exception Handling - and of course last but not least, properly handling errors and exceptions is another practice that effective developers never neglect.


Stay cool, be effective!