A collection of thoughts about "what makes a good developer"
- Frequent use of mouse for programming tasks. Navigates through code and files and performs operations using mouse.
- Is unaware of inefficiencies in personal workflow and does not invest thought or effort into honing
- Can navigate code and utilize IDE using memorized shortcut keys with extremely infrequent use of mouse
- Is self-aware of inefficiencies in personal workflow; has invested thought and effort into honing workflow, IDE configuration, tooling; continues to invest thought and effort in the pursuit of improving workflow
- Prolific multi-level nesting of code blocks
- Many functions/methods longer than 30 - 50 lines that have not been broken up
- Single-syllable naming of variables, methods, objects that do not reveal the intended purpose (non intention-revealing)
- Redundant comments that do not
- Use of comments as source control to document history (rather than using source control)
- Valuable comments that explain what something does beyond which can be easily inferred
- Comments that explain why a particular approach was used in the code to help future maintainers understand why it should be preserverd, or identify when it may no longer be valid
- Not aware of language idioms; does not research (i.e. Google) idiomatic approach to solving problems; uses naive (non-idiomatic
- Frequently re-invents the wheel: implements own methods
- Knowledgeable of all language features and applies them appropriately. For example, in C# use of enumerations, foreach, yields, lambdas, events, Linq, async/await, delegates, etc.. In Python: generators, list comprehension.
- Continuously "kludges" new functionality into existing code -- attempts as much as possible to add new code while avoiding touching existing code and avoiding re-factoring
- Can accurately describe refactoring actions in terms of Martin Fowler's "Refactoring" terms such as "extract method", "extract interface", "pull-up member variable" etc...
- Doesn't use source control
- Routinley goes days or longer without checking into mainline, or uses branches to avoid continuous integration of code
- Continuously integrates: Checks in code to mainline daily
- Able to perform basic operations
- Can clone a repo, i.e.
git clone - Can commit, adding only desired changes, i.e.
git add,git commit - Can pull latest
git pull - Can merge
- Can create, switch between branches
- Can stash and pop
- Can create tags
- Resourceful; uses multiple resources at disposal to research and troubleshoot, including documentation, examining code, Googling, Stack Overflow, writing automated tests, adding logging, debugging, comparing against samples, writing and testing simplified code, etc..
- Effectively decomposes the problem into isolated parts; develops hypotheses
- Applies knowledge, experience and intuition to rank likelihood of hypotheses and develop efficient approach for testing each
- Not afraid to request help at an appropriate time; is able to communicate with accuracy, brevity and clarity the specifics of the problem and existing troubleshooting
- Maintains abreast of new technologies and industry trends through Twitter, blogs, vendor news
- Invests effort into experimenting with new technology
- Can extrapolate opportunities when new technology may be an appropriate solution to an existing problem; equally, understands the limits of a new technology and when it may not be appropriate
- Is comfortable and confident in trial and failure -- trying a new technology that carries risk and being honest and realistic if it does not work as hoped.
Skills that are probably important but haven't been categorized yet.
- Using
sshto connect to a remote host - Using
scpto copy files to/from a remote host - Generating keypairs