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.
- Follow e-mail best practices (some examples)
- Follow chat best practices (some Slack examples)
- Minimize interruptions (some reasons)
- Be polite
- Practice empathy
- Keep low egos
- Be an active listener
- Be a good mentor
- Share knowledge
- Engage in constructive decisions
- Pull Request Best Practices
- Focus on the relevant pieces when performing code-reviews
- Pair programming best practices
- Comfortable with iterative and incremental development
- Self-organizing capability
- Avoid creating false expectations
- Focus on priorities and business value
- Don't fear change
- Dare to fail
- Be a life-long learner
- Be rational: question decisions, "let the facts do the talking"
- Basic control structures and Boolean algebra
- OOP
- SOLID, GRASP
- Functional programming (pure functions, recursion,...)
- Declarative vs Imperative programming (see differences)
- Basic structures (basic types, array, matrix, object...)
- Caching / memoization
- Hash codes, tokens, encodings (e.g. Base64)
- 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
- CVS / SCM knowledge
- Understand why versioning is important
- Commit best practices (micro commits / atomic commits, good descriptions...)
- Feature branches / feature toggles
- Trunk-based development
- Dependency management
- Build automation
- Write automated tests
- Differences between unit, integration and system tests
- Test pyramid
- Continuous Integration
- Continuous Delivery vs Deployment
- 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
- Relational databases (how they work, basic concepts...)
- Batch processes / Cron Jobs
- Database design
- ORM
- Session handling
- Error Handling, Auditing and Logging
- Externalized Configuration
- Infrastructure as code
- Microservices
- Virtual machines vs Containers
- Master-slave pattern
- Client-server pattern
- IAAS, PAAS, SASS
- Public-key cryptosystems (e.g. RSA)
- Principle of least privilege
- DoS / DDoS
- SQL injection
- Man-in-the-middle attack
- XSS and CSRF
- Load balancing
- Redundancy
- Latency
- Lazy loading
- Race condition
- Deadlock
- Mutual exclusion
This work is released under the terms specified in this license file, based on MIT License.