You’ve had problems with files. Probably due to their file extensions. Let’s say you wanted the last three characters to determine the file type. You ask some people questions about it.
You search for code to find the last three characters. Your coworkers probably have some suggestions, so you ask them as well.
You’re stuck on your solution, without looking back at the problem.
You’ve got into the XY problem. Let’s go into the details of it.
The XY problem is asking about your attempted Y solution. You should ask about actual X problem.
My first demo was filled with bugs. No CI was setup. Check-in — then pray. Errors were my fault, but they could have been prevented. I needed more robustness in my code.
Follow coding tips — write better code. This stands for every developer. Myself included.
I’ve used mentors to improve and grow. They’ve proposed solutions, books to read, and tips to follow. I read, learned, and implemented as soon as possible.
Let’s go through 3 key points every developer should know. You should not stop here, do your own research, and learn more than these.
I caused a halt…
I know. We all love Medium. Easy to use, no WordPress, somewhat free.
But what if? What if we can blog for free, with no WordPress, and load times are in seconds?
If you need all of this — visit bearblog.dev.
What is agile? Follow the agile manifesto and become an agile software developer. You could read more about principles here.
Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan — Agile Manifesto
Allen Holub doubts JIRA improves agility. He proposed this question on Twitter.
I’ve been working with JIRA for over a year. Does it improve agility? I don’t know. Let’s go through objections, review, and make conclusions.
Visualization of tasks improves agility. Teams can work asynchronously and deliver. …
You need to select, validate, or add constraints to your domain. Specification pattern, in a clear OOP way, does the before-mentioned.
Let’s go into details. Next up, specification pattern in Java.
Selection: You need to select a subset of objects based on some criteria, and to refresh the selection at various times
Validation: You need to check that only suitable objects are used for a certain purpose
Who is Joel? A software developer who created StackOverflow as we know it. We all know how the site works now.
Joel created a test and published it 20 years ago. This test consists of 12 steps to better code.
I thought this is an ancient test. I was wrong. Steps are evergreen, you can test yourself even today.
What are the test steps? Did something change? Do we still need these steps to write better code?
Stumbled upon this great book. You know learning — about code — never stops. Read through it in a beat.
You should too. You should read and implement as much as possible.
Listing out 5 critical takeaways. I’ll add an opinion on each. Enjoy.
Business wants you to solve a software issue. You pick the approach. Most developers do it as soon as possible. Add changes to existing code, don’t break anything, and go for a coffee break.
You need to avoid this approach.
Bad domain design leads to a lot of confusion. I am guilty of
You need to place business logic in the code. Where you write the logic depends on you. If you are working with OOP, then you need to think about it. You must adhere to the single responsibility principle.
… these objects are connected with the rich relationships and structure that true domain models have … there is hardly any behavior on these objects, making them little more than bags of getters and setters. — Martin Fowler
An anemic domain model is rich with relationships. Models don’t hold behavior, so the whole domain is filled with property bags.
We’ve all seen design patterns. From singleton to strategy design patterns. We take them as gods of programming sent them. Let’s ask 3 questions, you should always ask.
Do you overuse them?
Do you know when to apply them?
Do you know which one is great fit for my problem?
We are all guilty of overusing design patterns. This pattern will solve our problem, but we can’t decide.
Why are design patterns essential in our career as OOP developers? Let’s answer that question in this article.
Solving computational problems requires writing programs. The layout of the program depends on the programmer. Execution of programs depends on the computer, and we can’t control execution.
No one likes tangled code, and staying overtime to figure out what it does. You should write structured code, with a clear code understanding.
Structuring programs where one could comprehend code leads to structured programming. What can we do to structure our programs? Let’s continue to expand on this topic.
What can we do to shorten the conceptual gap between the static program text and the corresponding time computations? — Edsger W. Dijkstra