brainbaking/content/wiki/books/productive_programmer.md

121 lines
4.8 KiB
Markdown
Raw Normal View History

2017-02-26 13:28:18 +01:00
+++
title = "productive_programmer"
draft = false
tags = [
"books",
"productive_programmer"
]
date = "2013-03-12"
+++
# The Productive Programmer
Author: Neal Ford<br/><br/>
{{< lib "Productive programmer|Librarything Link" >}}
Dit is een samenvatting van alle **notes** in essentie, opgedeeld per hoofdstuk.
## Part 1: Mechanics
### Acceleration
* Concentrate on essence, not ceremony.
* The usefulness of an application list is inversely proportional to its length.
* Eye candy looks goot but isn't nutritious.
* Typing is faster than navigation.
* Prefer typing over mousing.
* The address bar is the most efficient Windows interface.
* Take the time to learn all the hidden keyboard shortcuts of your universe.
* Context switching eats time.
* Clipboarding to batches is faster than clipboarding serially.
* Those who remember their history aren't doomed to type it again.
* Embedded command prompts give you access to the best of both worlds.
* Embed the command prompt to make it easier to switch contexts.
* When coding, always prefer the keyboard to the mouse.
* Learn the IDE keyboard shortcuts in context, not by reading long lists.
* When you type a complicated construct for the second time, templatize it.
* For any symmetric operation on multiple lines of text, find a pattern and record a macro.
* The more times you perform a particular operation on a chunck of text, the greater the likehood you'll do it again.
* Don't type the same command over and over again.
* Spend a little time each day to make every day more productive.
<img style='float: left; width: nolink&|px;' src='/img//books/angry_monkeys.png'>
### Focus
* The higher the level of concentration, the denser the ideas.
* THe bigger the haystack, the harder it is to find the needle.
* Replace file hierarchies with search.
* Try simpler searching before resorting to "hard target" searching.
* Take advantage of built-in focus facilities like colors.
* Use links to create virtual project management folders.
* Virtual desktops unclutter your stacks of windows.
### Automation
* Use tools out of their original context when appropriate.
* Don't spend time doing by hand what you can automate.
* Performing simple, repetitive tasks squanders your concentration.
* Finding innovatige solutions to problems makes it easier to solve similar problems in the future.
* Timebox speculative development.
### Canonicality
* Keep a single copy of everything you don't build in version control.
* Use indirection to create friendlier workspaces.
* Use indirection to keep your life in sync (symlinks).
* No matter what you are copying and pasting, reuse by copy and paste is evil.
* Use virtualization to canonicalize dependencies for your projects.
* Don't let object-relational mapping tools violate canonicality.
* Add behavior to generated code via extention, open classes or partial classes.
* Always keep code and schemas in sync.
* Use migrations to create repeatable snapshots of schema changes.
* Out-of-date documentation is worse than none because it is actively misleading.
* For managers, documentation is about risk mitigation.
* Always keep "living" documents.
* Anything that takes real effort to create makes its creator irrationally attached to it.
* Whiteboard + digital camera > CASE tools.
* Generate all the technical documents you can.
* Never keep two copies of the same thing.
* Repetition is the single most diminishing force in software development.
## Part 2: Practice
### Statistic analysis
* Statistic analysis tools represent cheap verification.
### Good citizenship
* Don't create global variables, even the object kind.
### YAGNI
* Don't pay complexity tax unless you absolutely must.
* Software development is first and foremost a communication game.
### Ancient philosophers
* Maximize work on essential complexity; kill accidental complexity.
* Even general-purpose programming languages suffer from the "80-10-10" rule.
* Pay attention to the lore of "ancient" technologies. (Smalltalk lol)
### Meta-programming
* Meta-programming changes your syntactic vocabulary, giving you more ways to express yourself.
### Composed method and SLAP
* Refactoring to composed method reveals hidden reusable code.
* TDD predisposes composed method.
* Encapuslate all implementation details away from public methods.
### Find the perfect Tools
* Find your perfect editor and learn it inside and out.
* Record macros for all symmetrical text manipulations.
* Good knowledge of regexp can save orders of magnitude of effort.
* Don't make round trips when you can batch.
* Use a "real" scripting language for automation chores.
* Keep behavior in (testable) code.
* Pay attention to the evolution of your tools.
* Pay as little complexitax as you can.