Why is the software development process a complicated process?

Classification of problems

The Cynefin framework , originally developed by Dave Snowden in 1999, attempts to divide the world's problems into five domains (large categories):

Simple problem , the causal relationship in this domain is very obvious, the way to solve these problems is Sense-Categorise-Respond, there are corresponding best practices.

Complicated problems , causal relationships in the domain need to be analyzed, or some other form of investigation and/or expertise is needed. The solution to these problems is Sense-Analyze-Respond. Corresponding good practice

Complex problems , causal relationships in the domain can only be found in retrospectives. The solution to these problems is Probe-Sense-Respond, and we can perceive emerged practice.

Chaotic problem , there is no system-level causality in the domain, the method is Act-Sense-Respond, we can find novel practice (novel practice)

Disorder problem, there is no causal relationship in the domain, it is not perceptible, and the problem cannot be solved.

Obviously, the software development process is more of a complex issue. Before a product is developed, the uncertainty is very high, and the team (including business people and technicians) has the least knowledge of the product, and it requires a lot of learning and experimentation to clarify the possible direction of the next step. Unfortunately, many times we need to plan for the project at the beginning (when the uncertainty is highest). This method, which is very suitable from the traditional industry, is no longer applicable in the field of software development, which is why agile development, lean and other methodologies are more suitable in software development.

Just because software development is actually a learning process, the new knowledge we learn will in turn help us define the problem and bring about change. The changes here may come from two directions: functional non-functionality.

Functional change refers to changes that occur as a result of a deep understanding of the business or existing business rules to match the market. For example, the payment method has changed from traditional cash on delivery to online banking payment, and has become WeChat payment, Alipay scanning code and so on. An original e-commerce platform only provides basic shopping services, but can later generate recommended merchandise based on existing data, resulting in greater traffic. These changes need to be reflected in the existing code, and the modification of the code is often a one-stop move.

Non-functional changes refer to new demands arising from the development of the business, the increase in the size of users, the change in the amount of data, and changes in security awareness. For example, 100 users do not need to consider performance issues, but when 1 million users, performance becomes a problem that must be taken seriously. The data security of weather forecasting applications and the data security requirements of online banking are also very different.

When the business puts forward a demand, it is often just a simplified version.

Non-functional complexity

This is a designer-designed interface that the user can't actually describe accurately before it is designed. The design process has experienced a lot of things like:

Wireframes

Color determination

Interactive animation

Information hierarchy

After a number of reciprocations, the interface is determined. When you don't think about the usage scenario carefully, development mistakenly thinks that this feature is very simple. But if you are an experienced developer, some of the questions you will soon think of are:

How to display in widescreen

How to show on the tablet

How to show on your phone

Even if you only support the desktop version, cross browser considerations? Which versions are supported?

Some UI effects don't work on lower versions of the browser, you need Shim technology

In addition to this, there are still plenty of other details to consider:

What is the performance requirement?

Is security to be considered?

When the network environment is not good, do you want to fallback to the base view?

Since it involves sending invitations, how is the delivery rate guaranteed?

Workload when integrating with an external mail service provider

and many more. This implicit information needs to be fully explored, and then the developer can make a reasonable assessment, and this is only the beginning. Once in the development phase, many details that were not considered before began to emerge: font selection, font size, font color, spacing between elements, etc. How to test whether the mail was sent successfully, and the conversation between multiple characters would take a lot of time. .

Direction of change in demand

As a programmer, one day you are asked to write a piece of code, this code needs to complete a very simple thing:

Print "Hello, world" 5 times

It's easy, you think, and then write down the following lines of code:

Print( "Hello, world" ) print( "Hello, world" ) print( "Hello, world" ) print( "Hello, world" ) print( "Hello, world" )

However, copy and paste looks a bit low-end, you made a minor change:

For ( var i = 0 ; i < 5 ; i++ ) { print( "Hello, world" ) }

It looks pretty good, and the boss's needs have turned into "Goodbye, world" five times. Since it is printing different messages, why not use the message as a parameter?

Function printMessage(message) { for (i = 0 ; i < 5 ; i++ ) { print(message); } } printMessage( "Hello, world" ) printMessage( "Goodbye, world" )

With this function, you can print any message 5 times. The boss changed the demand again: print "Hello, world" 13 times (no one knows why it is 13). Since the number has changed, one might be passing the number as a parameter:

Function printMessage(count, message) { for (i = 0 ; i < count; i++ ) { print(message); } } printMessage( 13 , "Hello, world" ); printMessage( 5 , "Goodbye, world" );

Perfect, this is the charm of abstraction. With this function, you can print any message any number of times. But the boss can never be satisfied. On the second day after the change in demand, his needs have changed: not only to print "Hello, world" to the console, but also to count it.

No way, by searching the JavaScript documentation, you find something called a higher-order function: the function can be passed as another parameter to another parameter!

Function log(message) { system.log(message); } function doMessage(count, message, action) { for (i = 0 ; i < count; i++ ) { action(message); } } doMessage( 5 , "Hello , world" , print); doMessage( 5 , "Hello, world" , log);

This is awesome, we can do any number of arbitrary actions on any message! Go back and look at the initial needs:

Print "Hello, world" 5 times

Slightly split this sentence: print, "Hello, world", 5 times , you can see that these three elements have finally become changeable points, software development is often the case, the demand may change at any time The direction changes. This is also the problem that various software development principles try to solve: how to write code that is easier to extend and more responsive to change.

summary

The complexity of software comes from a lot of uncertainty , and this uncertainty is in fact unavoidable, and every piece of software is unique. On the other hand, software requirements change in a variety of ways, and often in a direction that developers don't anticipate. As seen in the small example above, the final requirement may become to send the message to the user's mobile phone whose mobile number starts with 185.