- Harendra Kumar Kanojiya
Think before you code. I offer this guidance to each lesser specialist I meet. However most more youthful designers struggle with following it.
Setting aside some margin to dial back and think will make you a more effective architect and a superior investigator and issue solver.
We should take a gander at three situations where this is pertinent: in new employee screenings, in bug fixing, and in include improvement.
It's a typical slip-up during whiteboard meetings to begin coding before you completely figure out the issue. The questioner probably gave you an issue proclamation that deliberately or unexpectedly had many subtleties forgotten about.
For example, what suppositions might you at any point make? What are your requirements? Could you at any point accept that you will generally be given legitimate information, or do you have to make preparations for invalid contentions? Will the dataset be little enough that you can adopt a savage power strategy, or do you have to enhance your calculation for explicit space or time imperatives? Pose inquiries until you feel that you completely figure out the issue.
Then, what experiments would it be a good idea for you to consider? It's not unexpected not important to work out completely useful tests during a coding exercise, yet it's really smart to write down the sorts of information you might want to test and the normal result for every one. For instance, assuming you are composing a capacity that decides whether a string is a palindrome, you should have essentially the accompanying as your test inputs: racecar, early afternoon, canine, moon, 42. With those five experiments, you're ready to consider how your code ought to deal with palindromes of even or odd length (racecar and early afternoon), strings of even or odd length that are not palindromes (canine and moon), and invalid information (42). I'm certain you can imagine other experiments to consider too.
At long last, would you say you are ready to think of some pseudocode to approve your methodology at a significant level? Prior to diving into the quick and dirty subtleties of the genuine code, it's smart to thoroughly consider how you could handle the issue so you can get issues in your methodology from the beginning.
While investigating an issue, unpracticed engineers will quite often overreact. They start wildly attempting different things trying to determine the issue. This is a misstep. Interruption and set aside some margin to thoroughly consider the issue.
What do you have at least some idea that changed between when the code was working and when it wasn't working? Assuming that you redesigned the form of a reliance, what does the changelog between the two adaptations seem to be? In the event that the code chips away at your machine however not in a test climate, what's different between the two conditions? Assuming the previous delivery turned out great yet the present delivery has a bug, what commits were remembered for the present delivery that may be the guilty party? On the off chance that you don't have any idea where to begin searching for the main driver of the issue, who could you have the option to ask that might have a few bits of knowledge into what's going on?
Requiring even only five minutes to contemplate the issue before you begin attempting to fix it might wind up saving you hours over the long haul.
Growing new usefulness ought to start with an arrangement. What acknowledgment models do you have to meet to address the client's issues properly? Do you have experiments worked out, either in real executable code or list items to consider? Assuming planning an API endpoint, what should the information sources and results be? In the event that working with complex information, what kind of information design could best address the information?
Invest energy planning your code prior to hopping in. You might be in a rush to begin coding, however getting some margin to plan will save you agonizing modifies not too far off.
Junior architects hop directly into coding without completely grasping the issue or thoroughly considering potential arrangements first. So before you start quickly composing — stop. Think before you code.