Design Tips for Novice Developers

Introduction

Software development is a complex process, and design is a key skill that every developer needs, not just a specific person like an architect. Design is a critical step in determining the overall structure of a program, defining how each feature will interact with the others.

However, the importance of design is often underestimated, especially when developing for simple issues that are often encountered by novice developers. While this may feel different depending on your perspective or role, design is ultimately an important task for all developers.

However, when new developers are given their first development assignment, they often do not know where to start. Their technical understanding is not yet sufficient and they lack a wide range of experience, so it is natural that solutions do not immediately come to mind.

In this situation, it is helpful to take the first steps and follow a planned procedure. First and foremost, you need to have a basic understanding and preparation to start development. This will help you understand the problem and plan how to solve it.

In this post, I would like to provide a few quick tips for those of you who are feeling a little lost about where to start when you start developing like this. These tips will help you understand the development process a little more clearly and get started effectively.

Design the most fundamental features

At the start of software development, writing a feature list has a simple but powerful effect: it gives you a more concrete and clear picture of your development goals, which may have seemed vague at first.

For example, let's say you need to develop a job called "Member Management". With little additional information, this might seem like a fairly abstract and vague mission. In this situation, it is helpful to break the task down into smaller pieces, like building a tree. As you do this, it will become increasingly clear what problems you need to solve and what features you need.

This process of slicing and dicing helps you break down complex problems into smaller ones, each of which can be understood and solved separately. It is a practical application of one of the core principles of design: divide and conquer. With this method, even novice developers can effectively manage and solve complex problems.

Among other things, feature designs help you gauge the scope of development and provide a basis for schedule estimates.

In these situations, you can decompose a given mission into smaller tasks and create an estimate for the time for each smaller task. This will give you a much more accurate estimate than trying to estimate the entire task at once.

However, perfect schedule forecasting is difficult, so you need to set a certain amount of slack time. This slack time acts as a "buffer" for your schedule forecasts, and as you iterate on these forecasts and feedback, you will get to a point where you can manage your schedule within this buffer.

In fact, breaking down development tasks into smaller chunks and setting milestones greatly improves the overall management and efficiency of a project. It gives you a clear picture of progress at each stage and allows you to react immediately when issues arise. It also helps your development team manage the schedule with a clear understanding of the overall project.

There are many ways to estimate your schedule, and you should choose the appropriate method for your situation. I use two methods in particular.

The first is to estimate time by measuring the level of difficulty and certainty for each feature.

We distinguish difficulty levels as follows.

High: Requires outside help or considerable effort
Medium: Can do it oneself
Low: It is a simple task

We distinguish certainty levels as follows.

High: Requirements and implementation direction are clear
Medium: The implementation method is not yet clear
Low: The requirement is abstract or the implementation method is vague (Task should not start development, requires further analysis)

The time estimate is low because it only considers the pure time to implement the feature. It would be ideal to factor in testing or other tasks, but in practice, this is not very helpful because you cannot predict what changes will occur.

In the end, the predicted time is calculated as follows

Estimated time: f (difficulty) * g (certainty) * estimated time

Here, the difficulty function, f, and certainty function, g, adjust the coefficient values to match the skills of the team members to find the right values. As you iterate through releases, you improve the accuracy by correcting for any deviations from expectations. This way, you can gradually increase the accuracy of your development schedule estimates.

For the original sheet described above, please see the link below.

https://docs.google.com/spreadsheets/d/1N68bKZyG8FD4TH7w_U_CbWLrDUM1cHBP3vxVnjOn_ww/edit?usp=sharing

'O' stands for optimistic time. This is the time required if everything went perfectly. 'M' stands for most likely time. This means the time for the most likely scenario. 'P' stands for pessimistic time. This means the time for the worst-case scenario.

This is a schedule estimation formula used by a project management technique called Program Evaluation and Review Technique (PERT). PERT was developed by the United States Navy and is used to manage schedules for projects with high uncertainty.

Reference link: https://en.wikipedia.org/wiki/Program_evaluation_and_review_technique

Dynamic design helps when dealing with non-simple problems

When you need to solve a complex problem, it is very helpful to use dynamic design. Diagrams like the one in the following image are used, which serve the purpose of separating the system into different objects and showing how they need to communicate with each other.

The important thing in this process is to find the dependencies between the objects, rather than the flow itself. The biggest benefit of dynamic design is that it allows you to validate your requirements and ideas at very little cost before you write any code.

For a working example of the diagram above, see the link below.

There are many other ways to approach the dynamic design process besides the one I use. Consider leveraging the popular Unified Modeling Language (UML). UML is a useful tool for visually representing the behavior of a system.

When it comes to dynamic design, UML includes activity diagrams, sequence diagrams, communication diagrams, and state diagrams, among others.

Activity diagram: Represents the behavior of a system sequentially.
Sequence diagram: Represents the interactions between objects in chronological order.
Communication diagram: Similar to a sequence diagram, but focuses more on the relationships between objects.
State diagram: Represents changes in the state of objects.

If the problem becomes more complex, the structural design can beStructural design defines the overall structure of the system by utilizing things like class diagrams and component diagrams. These diagrams clearly represent the components of the system and the relationships between them, which helps developers understand the overall organization of the system.

As a system becomes more complex, it is not enough to have all the features logically implemented; you need a way to effectively manage the increased complexity. This is where structural design becomes even more important.

Structural design helps break down a complex system into multiple manageable parts. This allows each part to be developed and tested independently, which contributes to the quality of the overall system. Therefore, structural design is an essential step in building complex systems effectively

Closing thoughts

This is a brief overview of the fundamentals of design: functional design, dynamic design, and structural design. There are many great resources on design, and we encourage you to check them out. However, there is no "right" answer to design, as the scope and methodology can vary greatly depending on the context.

Therefore, it is important to study different theories without bias and apply them in practice. You will notice that your problem-solving skills will gradually improve as you go along. Developing design skills is more than just writing good code. It is about understanding complex problems and being able to solve them effectively.

Thank you.

목차

Introduction

Design the most fundamental features