We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
DPC2019: Good or bad - a key skill for developers - Dan Ackroyd
"Learn how to develop effective decision-making skills as a developer, including recognizing and learning from mistakes, prioritizing ease of use, and embracing imperfections in code."
- Poor decision-making skills are a common issue among developers.
- There is no objective measure of what is good or bad code, and it’s up to individuals to recognize and learn from their mistakes.
- English language has many quirks and inconsistencies, and speakers often use correct grammar without thinking.
- The concept of “good” and “bad” coding habits is subjective and influences how developers make decisions.
- Codebases often become messy over time, but refactoring and rewriting code from scratch can be beneficial.
- The author of this talk has a strong opinion about code quality and believes that ease of use should be prioritized over features.
- Many developers are not happy with the idea of debugging tools being available immediately, as it disrupts their workflow.
- Codebases should be written with consideration for future maintenance and scalability.
- Writing down decision-making processes and reviewing them later can help developers make better choices.
- Team decision-making can be beneficial, but individuals should also take ownership of their decisions.
- There is no perfect way to determine what is good or bad code, but developers should strive to improve their decision-making skills.
- Humans are not always rational and emotions can influence decision-making.
- The concept of “kintsugi” (repairing broken pottery) can be applied to software development, by acknowledging and celebrating the mistakes and imperfections.
- There is no such thing as a “good” language or framework; each has its own strengths and weaknesses.
- English language has many irregularities, making it difficult to predict how words are pronounced and spelled.
- When introducing new features or code, it’s important to consider the trade-offs and prioritize ease of use over features.
- Debuggers should be immediately available for rapid debugging.
- Features can often make code harder to use, but solving less important problems can be helpful.
- Developers should strive to create software that is easy to use, even if it’s not the most advanced.
- Code should be written with the end user in mind, not just with a focus on features.