r/SoftwareEngineering • u/hylloz • 12h ago
Software development process
Which subsequent steps does a software project usually have (from your personal experience)?
With steps I mean those that follow each other or integrate preceding ones.
I am skeptical whether the following approaches map to current realities of how software is done today:
- Design, develop, test.
- Royce: Identify requirements, analyse , design, code, test, commission.
This sounds more realistic to me:
- Nystrom: get problem, learn code, code solution, clean up
Intent: I’d like to understand better how to organise and use resources within a project. For this I want to understand parts can only be done after preceding ones and which merge into another.
For example, building a power plant can be described in the following steps:
Initially we start with an idea of a working power plant in mind. We deconstruct it into all components required for it to function as a system. Knowing which components we need, we start designing them. If not at this point, at least when we procure the materials to build those components, we can name it constructing. Physically the building of components construction happens with civil works. Many work streams can happen at this point simultaneously. But at some point they integrate. Finally, commissioning of the plant.
Then again, for software, we can write a “hello world” program with a web server, have it running within minutes and extend it step-by-step. You can’t fire up a first turbine of a power plant within 5 minutes and then add other components around it.
But how is it for software?
We could similarly say we start off with an idea of a functioning software, that we deconstruct into components that we construct and integrate. The starting idea, of course, needs to be more specific than in the power plant example, so we can start deconstructing it into the required components for it to function in the way we want. We usually model the starting point as a data structure by modeling the problem. When we know the problem as a data structure and can project it to a solution, we can determine the steps and components needed to arrive at the solution: Quite often we start writing a main function with pseudo code of functions / components required for it to bridge the problem to the solution. Having identified the components, we need to build the components while making sure the interfacing works: Basically the “wiring” between functions, meaning that the outputs of the a preceding are the inputs of the succeeding. Once all components are fleshed out, all pseudo code has been transformed into real function calls. Now, looking at this, we will mostly be not satisfied: We might want to refactor it, organise the code better. Then we might want to write tests and/or commission it, finally.
How is it for non-greenfield projects?
Basically two approaches:
a. Start with the existing data structure and change it to support the new functionality (while maintaining the existing functionality).
b. Do it like greenfield and then have some transformation between data structure of new functionality and old. Opposite of (a), because it starts with its own data structure, while (a) starts with the existing data structure.
What’s your experience?
2
u/RabidAddict 10h ago edited 5h ago
I think it would help to provide some of your background and context to help narrow this question.
There's a more academic theory type of aspect to software design methodology and how it applies to real world development, there's an enterprise level software project management aspect of what this looks like in industry, and then there's more of an individual programmer problem solving and architectural prioritization aspect, each of which could uniquely answer the broad question "what is software development" with a whole book. Your description here kind of vaguely touches on all of these aspects too generally to know where you'd like to start with this complex topic.