At its heart, software engineering is a series of feedback loops. HubSpot mentions that a feedback loop happens when a system's outputs are recycled as inputs. In its simplest form, this is true. However, it's far more complex than that in software engineering. Feedback loops occur many times throughout the software development cycle.
The most common feedback loop in software development is when a developer changes code and sees how it works. The feedback comes from the output. If the change brings about the desired effect, then the feedback loop returns positive. Otherwise, the feedback loop returns negative. On a negative result, the programmer would have to revisit the solution to search for other causes. There may be more than one underlying factor in the case of complex problems, leading to further feedback loops and testing.
Feedback loops like the above aren't true feedback loops. They are "micro-feedback loops." Larger, more complex feedback loops also function in software engineering. When the programmer completes a part of a project and integrates it into the system, testing follows. If the test returns results that aren't as expected, the developer needs to examine where the issue occurred. Sometimes this may result in seeing whether the interface between the systems may be buggy. Large-scale feedback loops extend to encompass things like consumer response and sales figures. Software engineering, in its purest form, is simply a series of interlinked feedback and micro-feedback loops.
If we want to optimize a system, we start with the most accessible parts of the system to optimize. In the case of software development, the most accessible place to start optimizing is these micro-feedback loops. The benefits from optimization might not be immediately apparent, but they add up. Developers in their state of flow proceed quickly through the stages of a development project. Optimization helps to avoid breaking that flow, keeping them engaged for a more extended period. The result is a far more efficient developer. But how does a developer find and implement the fixes to their micro-feedback loops?
Developers spend so much time working on their assigned areas of a project that they can quickly tell what works and what doesn't. The term "technical debt" comes up a lot in discussions like these. Product Plan mentions that technical debt refers to when a development team expedites development at the cost of efficiency. In many situations, developers who put their code into technical debt have to spend time later on in the development cycle paying back that debt.
Instead of a technical debt approach, teams should offer their developers time to work out the efficiency issues in their code. By doing so, the amount of time saved in refactoring inefficient code later down compounds on itself. The development team can then produce software far more efficiently, with the desired results coming in less time since they don't have to refactor the code.
Aside from the ground floor with developers, software companies sometimes try to optimize processes that shouldn't even exist. Occasionally, businesses do themselves a disservice in their process structure. Instead of looking at ways to solve problems within a process, it may be more fruitful to examine whether the process serves a purpose. Removing redundant processes will save the business time and money while making its operations more efficient.
Another issue with optimizing processes comes with focusing too entirely on speed and automation. While a faster process does crank out a product faster, the final product usually has to go through a quality assurance check. When combining the time that this check takes with the processing time, it's apparent that there are no actual savings. The burden simply shifts to a different process.
Instead, consider a value-based approach. Each step of the process should invest its time into ensuring that there's less to rework. In the event of methods that span across multiple organizations, stream mapping can help. Stream mapping helps an organization figure out where its points of friction occur to better manage an interface to reduce that problem.
It doesn't matter how innovative an approach is if the stakeholders aren't a fan of it. Developers may not be inclined to follow processes as outlines because they don't see the point. It will help to highlight the problems that occur throughout the process.
Tools exist that can show how much time and effort is taken up in technical debt. Presenting this information can help developers realize how much easier their jobs would be by performing minor updates to their internal feedback loops. Using education tools like Learn a Course Online could help developers spot the holes in their feedback loops and prompt them to plug them themselves.
The overall goal is a more efficient development cycle. However, for this to work, every developer must be on board.
Create your free account to unlock your custom reading experience.