I am a full stack developer specializing in React.js, TypeScript, JavaScript, and Python. I am passionate about writing clean, maintainable code. Please feel free to reach out to me!
- Cause of complexity is two. Dependencies and obscurity
- The ideal design tends to emerge in bits and pieces. Thus, the best approach is to make lots of small investments on continues basis
- Interfaces should be desinged to make the common case as simple as possible. Interface should be less and implementation should be bigger.
- It is a myth that we can get systems “right the first time.” Instead, we should implement only today’s stories, then refactor and expand the system to implement new stories tomorrow. This is the essence of iterative and incremental agility. Test-driven development, refactoring, and the clean code they produce make this work at the code level.
- Systems must be clean too. An invasive architecture overwhelms the domain logic and impacts agility. When the domain logic is obscured, quality suffers because bugs find it easier to hide and stories become harder to implement.If agility is compromised, productivity suffers and the benefits of TDD are lost.
- Remarkably, following a simple and obvious rule that says we need to have tests and run them continuously impacts our system’s adherence to the primary OO goals of low coupling and high cohesion. Writing tests leads to better designs.
- All too often we get our code working and then move on to the next problem without giving sufficient thought to making that code easy for the next person to read. Remember, the most likely next person to read the code will be you. So take a little pride in your workmanship. Spend a little time with each of your functions and classes. Choose better names, split large functions into smaller functions, and generally just take care of what you’ve created. Care is a precious resource.
- “duplication is far cheaper than the wrong abstraction”, and thus to “prefer duplication over the wrong abstraction”.
- The problem with “small functions” though, is that the quest for small functions ends up begetting even more small functions, all of which tend to be given extremely verbose names in the spirit of making code self documenting and eschewing comments.
- Hard to Read: This has already been stated before but it bears reiterating — an explosion of small functions, especially one line functions, makes the codebase inordinately harder to read. This especially hurts those for whom the code should’ve been optimized for in the first place — newcomers.
- Writing code every day makes lots of benefits as a developer.
- Code as habit. This is about a change that you’re making in your life for yourself not a change that you’re making to satisfy someone else’s perception of your work.
- Background processing. Your current task is frequently running in the back of your mind when I go for a walk, or take a shower, or any of the other non-brain-using activities I participate in.