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 (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
- Practice empathy
- Keep low egos
- Be an active listener
- Be a good mentor
- Share knowledge
- Engage in constructive decisions
- 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
- Applying the Scientific Method
- Researching skills
- Lateral Thinking
- Abstraction
- Creativity
- 5 Whys
- Risk management
- 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 (Object Oriented Programming)
- SOLID, GRASP
- Functional programming (pure functions, recursion,...)
- Declarative vs Imperative programming
- 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 (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,...)
- Pull Request best practices
- Focus on the relevant pieces when performing code-reviews
- Pair Programming best 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
- 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
- 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
- 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.