"Work Smarter...Not Harder"
Allan F. Mogensen
But what does it really mean, particularly when it comes to software development?
- get organized immediately and cleanup often
- being consistent is more important than being right
- be very sensitive to scale (bigger systems mean less shortcuts)
- utilize the full abilities of any technology or tools, but don’t abuse them
- automate as much as possible, spend the time to get it reliable
- minimize dependencies, accept them only when there are really no other options
- read the manual first, even if it is boring
- research before you write code, avoid flailing at a problem, seek expertise
- choose to refactor first, before coding
- delete as much code as possible
- encapsulate the subproblems away from the system, spend the time to get it right
- break the problem cleanly, fear special cases
- apply abstraction and generalization to further reduce the work
- think very hard about the consequences before diving in
- fail, but admit it and learn from it
- don’t be afraid of the domain, learn as much as possible about it
- focus on the details, quality is all about getting them right
- accept that complexity breeds below the surface, if you think something is simple then you probably don’t understand it yet
- know the difference between knowing, assuming and guessing
- everything matters, nothing should be random in software
- don’t ignore Murphy’s law
- a small number of disorganized things doesn’t appear disorganized until it grows larger
- reassess the organization as things grow, updating it frequently as needed
Working smarter is most often about spending more time to think your way through the problems first, before diving in. Under intense time pressure, people often rush to action. There are times when this is necessary, but there is always a cost. Rack up enough of this technical debt. and then just servicing it becomes the main priority, which only amplifies the time pressure. Thus any gains from swift action are lost and working harder won’t undo the downward spiral.
Being smart however can prevent this from occurring. Yes, the pace is slower and getting the details right always requires more effort, but a minimal technical debt. means more resources are available to move forward. Eventually it pays off. Being smart isn’t just about thinking hard, it also requires having enough data to insure that the thinking is accurate. Thus, acquiring more information -- dealing with the details -- is the key to being able to amplify one’s thinking. In software development, what you don’t understand can really harm you and it’s very rare that you can ignore it.