Evergreen Skills for Software Developers
This repository includes a list of "evergreen skills" that should serve as a fair assessment of skilled software developers / engineers.
The purpose of this work is to serve as an alternative resource for conducting hiring interviews of software developers / engineers. This document focuses on software development best practices, cross-framework principles and other portable skills; instead of the usual focus on trends and/or specific knowledge of short-lived frameworks, which tend to quickly become outdated and often don't reflect the real value software developers / engineers bring to the organization.
This repository is a derivative work of the following article: "What Makes a Great Software Engineer".
This is a work in progress. Important knowledge might be missing, existing bullets can probably be improved and better grouping strategies could be found. For those reasons, any contributions (i.e. PRs) are welcome. Please feel free to propose changes following the contributing guideline.
Table of contents
Non-technical skills
Core Skills (aka "soft" skills)
Communication
- Follow e-mail best practices (e.g. some e-mail etiquette rules)
- Follow chat best practices (e.g. use threads to organize discussions and other best-practices from Slack)
- Minimize interruptions
- Be polite
Teamwork
- Practice empathy
- Keep low egos
- Be an active listener
- Be a good mentor
- Share knowledge
- Engage in constructive decisions
Innovation & (self-)management skills
Development process
- Know about Agile Software Development principles
- Be comfortable with iterative and incremental development
- Have self-organizing capabilities
- Avoid creating false expectations (e.g. with time estimates)
- Focus on priorities and business value
Problem solving skills
- Applying the Scientific Method
- Researching skills
- Lateral Thinking
- Abstraction
- Creativity
- 5 Whys
- Risk management
Mindset
- Don't fear change
- Dare to fail
- Be a life-long learner
- Be rational: question decisions, "let the facts do the talking"
Technical skills
General technical knowledge
Principles
- Basic control structures and boolean algebra
- OOP (Object Oriented Programming)
- SOLID, GRASP
- Functional programming (pure functions, recursion,...)
- Declarative vs Imperative programming
Data structures
- Basic structures (basic types, array, matrix, object...)
- Caching / memoization
- Hash codes, tokens, encodings (e.g. Base64)
Clean code
- Self-explanatory code
- Use good naming (for files, variables, classes, functions...)
- Avoid long functions and classes
- Extract complex boolean conditions into functions
- Use lightweight documentation instead of inline-comments
- Semantic versioning
Source Code Management
- CVS (Control Version Systems) / SCM (Source Code Management) basics: branches, tags, centralized vs de-centralized,...
- SCM vs repository management / hosting (i. e. difference between Git and GitHub)
- Understand why versioning is important
- Commit best practices (micro commits / atomic commits, good descriptions...)
- Feature branches (short-lived)
- Trunk-based development
- Dependency management (the importance of package managers, the risks of dependency hell,...)
Technical collaboration
- Pull Request best practices
- Focus on the relevant pieces when performing code-reviews
- Pair Programming best practices
DevOps practices
- Build automation
- Write automated tests
- Differences between unit, integration and system tests
- Test pyramid
- Continuous Integration
- Continuous Delivery vs Deployment
- Feature Flags / Feature Toggles
Field-specific technical knowledge
Front-end development
- DOM (definition, understanding, virtual DOM...)
- Responsive design (purpose, advantages, progressive enhancement...)
- API standards: REST / SOAP
- State management (associated problems, stateless approach...)
- MVC and derivatives
- WebSockets
Back-end development
- Relational databases (how they work, basic concepts...)
- Batch processes / Cron Jobs
- Database design
- ORM
- Session handling
- Error Handling, Auditing and Logging
Architecture & infrastructure
- Externalized Configuration
- Everything as code (i.e. Configuration as code, Infrastructure as code, Docs as code,...)
- Microservices
- Virtual machines vs Containers
- Master-slave pattern
- Client-server pattern
- IAAS, PAAS, SASS
Security
- Public-key cryptosystems (e.g. RSA)
- Principle of least privilege
- DoS / DDoS
- SQL injection
- Man-in-the-middle attack
- XSS and CSRF
Scaling & optimization
- Load balancing
- Redundancy
- Latency
- Lazy loading
Concurrency
- Race condition
- Deadlock
- Mutual exclusion
This work is released under the terms specified in this license file, based on MIT License.