How not to rush?

Question

I often find that I do part-time work on a function, especially at the design stage. I found several reasons:

• I'm too optimistic
• I feel the need to provide quick solutions, so sometimes I fool myself into thinking that the design is flawless when it is actually full of holes in order to get the job done faster. Of course, I will end up paying dearly later.

I have been aware of this behavior for some time, but still believe that I am not able to compensate for this. Have you encountered similar problems? How do you approach their solution?

Answer 1

I use a couple of methods. The first is a simple to-do list. In the morning, I write down my tasks for the whole day. I try to work on a task until I can cross it. I cross it only when I acted on my satisfaction. My to-do list helps me focus. When a break occurs, I can consciously choose whether it is important enough to interrupt what I am doing now.

The second method that I use is to abandon the idea of ​​“making” for design. Instead, I focus on what I began to call “successors,” where design goes through predictable steps. Each stage well supports the current functionality and at some point will be performed in the next stage. This allows me to do a good job, a job that I can be proud of, without over-designing.

I have an intuition that there is a small catalog of such sequences (e.g. http://www.threeriversinstitute.org/FirstOneThenMany.html ) that will cover most of the design. In the meantime, I try to remember that "enough days are problems."

Answer 2

I often run into this problem.

My solution is a laptop. (Old fashioned paper look).

I write how I plan to implement the solution in the form of a list with a red list, and then try to identify each point in the list.

Often during this process, I run into problems that I did not even think about.

Of course, the 80/20 rule still applies ... I am still confronted with things when I actually perform an execution that did not occur to me, but with experience they tend to decrease.

EDIT: If I'm still not sure at the end of this process, I put together a test prototype prototype ... It is important to make sure that it is thrown, because otherwise you risk including some nasty hacks in your real code base.

Answer 3

Very often skip edges and details when you are at the planning stage of a project, especially in the field of software development. Please do not feel that this is a personal failure; it is something endemic.

To counter this, many software development methodologies have emerged. Most recently, many development groups have been replaced by “flexible” methods, which focus on rapid development with a small preliminary technical design (in the end, many difficulties are discovered only when you actually begin to develop). I am currently using the Scrum system, which was great on my small team:

http://en.wikipedia.org/wiki/Agile_methods

http://en.wikipedia.org/wiki/Scrum_%28development%29

If you find that your organization does not agree with what they might see as a radical change in approach, it might be worth exploring if they would agree to develop a prototype system. This means that you could compile a code to study the technologies involved and judge how possible it is without any obligation to fully develop a quality panel, test schedules, etc. The prototype must be discarded after the feasibility has been proven or disproved, then proper development can begin, including everything that you learned in the process.

If your problem is more about time management, I would recommend the Getting Things Done approach ( http://en.wikipedia.org/wiki/Getting_things_done ). It is pragmatic and simple, focusing on making you productive, without overloading you with information that is not directly related to your current work. I found that from time to time I am overwhelmed with project ideas / functions, and it really helps to record everything and write them down later, when I have the resources available for effective work.

Hope this helps and good luck!

Answer 4

Communication

The best way to not rush into programming errors is through communication. Yes, good reputation. If another person in the office is involved in this process, the better the result. If a programmer simply takes on the task without any problems for anyone else, then there is a higher probability of errors.

Accountability Checklist:

• How do we support this?
• Who needs to know what has changed?
• Why do we do this in the first place?
• Will there be someone who does not want this to change?
• Does anyone else understand how I did this?
• How will the user perceive and use this change?

A fellow skeptic is usually good enough to help. Functional characteristics are good, they usually answer all these thoughts. But sometimes talking with another person can help you with this, and you can quickly get changes in the doorway.

Answer 5

I learned that through years of mistakes (although they still made them) that almost everything that I want to use repeatedly or distribute should be properly designed. Thus, burning enough time will end your optimism.

When you get pressure from the leadership, I tell them that I still have to delve into the thoughts, so I have to do it when it's cheap. I also think on paper, so I can actually prove that I'm doing something, and this keeps my fingers on the keyboard, both of which provide a soothing effect for the guide .; -)

Answer 6

At the risk of appearing obvious is being pessimistic. I had several impressions when I thought “what should take several hours” and it ended up taking a couple of days due to all the little things that suddenly appear.

To date, the best way I've found to manage things is (like Andrei's answer) to write out the design and requirements as a starting point. Then I look through and look for design weaknesses, gotchas and additional use cases, etc. I try to consider this as an important exercise - there is still no code, so it is time to be absolutely ruthless and look for every weak spot. Look for the error conditions that you have to handle, and no matter how long you think it takes to complete each function / function, enter this amount for a lot. I had times when I doubled my initial rating and still not so far from it.

It is very difficult for a programmer to realistically design debugging time - writing code is easy to evaluate, but debugging, that is, functioning, real code is something completely different. Therefore, I do not find any exact science there, but I just put tasks on a whole bunch, so that I have enough respite for debugging.

See also Evidence-Based Planning , which is a fascinating planning concept developed by FogCreek for their FogBugz product.

Answer 7

You and the rest of the world.

You need a more detailed design, a more accurate assessment and a willingness to accept that sometimes the optimal solution is not necessarily the best solution (for example, you can code some loop in assembler to get optimal performance, but it will take much more time than just doing

for (i=1; i<=10; i++) {} 

) Has the time taken to ensure that it is really worth the batch of accounting over the rocket system.

Answer 8

I like to develop, but over time I found that a lot of the design ahead is very similar to building castles in the sky - it is too much speculation, but well educated, the lack of critical feedback from the actual implementation and use of the design.

So, today I much more agree that when I implement design I learn a lot about it, and I need to feed this training into design. This is a skill that is interesting to learn, including the ability to maintain design flexibility, keeping it simple, free from duplication and connectivity and decoupling, with changing the design in small controlled steps (= refactoring) and writing the necessary extensive set of automated tests that make such changes safe.

This seems to be a much more effective approach to me than an improvement in “pre-sale design specs” - and, in addition, it makes me equally well prepared for the inevitable moment when the design needs to be changed due to just an unexpected change in requirements.

Answer 9

Divide, divide, divide. List all the steps that will be required to complete the project, and then list all the steps that will be required to complete these steps, and so on, until you reach the atomic elements that you are absolutely sure that you can finish in a day or less. Add the duration of all these values ​​over a period of time.

Then double it. Now you have a number that, if depressing, is at least somewhat realistic.

Answer 10

If possible, "Dream on your design" before publishing it. I found that after I leave, I usually think about the things that I missed. This usually happens while I am in bed before falling asleep or even the next day.

I also find it valuable to have a peer / friend whom I trust in the review that I have before distributing it. Someone else almost always sees something that I did not think about and was not distracted.

Answer 11

I like to do what others have said. Write in pseudo-code what the flow of your application will be. This immediately highlights some detailed areas that may require further attention if not seen up.

Pseudo code is also read by business users who can verify that your approach meets their needs.

Using pseudo-code also creates a good set of methods that can be used as an interface in the final solution. Once the pseudo-code is hard enough, find the patterns and look at some common GOF patterns. They should not be perfect, but their use will deprive you of the need to rewrite the code later during the revisions that are sure to come.

Just taking an hour or two, writing psuedo code gives you some invaluable time savings: 1. An object model arises 2. The program flow is clearly defined for others 3. It can be used as documentation for your design with some refinement 4. Comments are easier to add and become more understandable to someone else looking at your code.

Good luck to you!

Answer 12

I found that the best way to make sure you choose a good design is to make sure you understand the problem, know the limitations that you have, and know what things you should have or not. -haves.

Understanding the problem will consist in talking to people who need help and their attachment to what needs to be done first, and not how they think it should be done. Once you know what is really going to happen, you can come back and discuss the requirements for how.

Knowing your limitations can be quite simple: you need to run it on the iPhone; There must be a web application Integrate with existing Java code and deployment configuration and so on. It can be quite difficult: you do not know what potential size of your user base is (hundreds? Thousands? Millions?); you don’t know whether you need to localize it (although if you’re not sure, suppose you have to).

Must-haves vs nice-to-haves: this is probably the hardest part. Users very often have emotional attachments to “requirements” (“It should look just like Excel”), which are not really part of the “should happen”. You often have to manipulate functionality and desires to get an acceptable implementation. You can’t always give everyone a pony.

Make sure you record it all! Even if it develops along the way, or the design is small, having “this is what we plan to do now,” the guide to which you refer when you need to make a decision on the transfer of resources makes it easy to deter yourself from implementing a really cool whiz-bang function, not a boring necessity.

Answer 13

Since you realize that you feel the need to provide a quick solution, it may slow you down to understand that you can probably solve the problem faster and complete it faster if you spend more time developing it. For example, if you spend 3 hours developing and 30 hours writing code, this probably means that if you spend 6 hours designing, you may only need 10 hours writing code. (These are not actual numbers, just examples). You can try to quantify this for yourself in the next few projects that you are doing. Make a couple in which you behave, as usual, and see what relation to design / coding / testing and debugging you really do. Then on the next project, consciously increase the percentage of time spent on the design phase, and see if it reduces the time needed for other stages. You will have to try several projects on this in order to get a true foundation, since projects can be completely different. Do this as a test to see if you can improve your productivity at other stages and thereby provide a faster product if you spend 20% more time or 50% more time or 100% more design time.

Remember that later in the process you will find that the design problem is more complicated (and takes a lot of time) to fix.