kentoh - Fotolia
Software developers should strive to reduce code redundancy in their applications. You rarely need to create two elements that perform that same function. If a program looks for a keyboard input, for example, there should be only one routine to gather that input. A second keyboard input routine is unessential at best and inefficient at worst. Additional routines require extra time to create, test and maintain.
Many programmers embrace Don't Repeat Yourself (DRY) as a mantra against code redundancy in software development. The DRY principle goes that the most efficient code, which uses the lowest amount of resources possible, is only represented once within a whole system.
The implementation of DRY code starts with human factors. Plan to design and write modular code from the beginning of a project, and enforce DRY principle results. If the modules are small and reusable from the design phase, the resulting code is much likelier to be DRY. Code reviews also help reinforce the DRY principle and reduce code redundancy. Developers should periodically access implementation guidance to ensure that code meets expectations. Additionally, there are tools that help dev teams manage code and enable easy component sharing.
The inverse of the concept is Write Everything Twice (WET). WET, a snarky term, implies that functions and tasks exist in two or more places throughout the code.
Repetition creates more lines of code, which means more content to read and comment on. More lines of code also mean more opportunity to introduce errors and security flaws, and the executable results are larger to build and deploy. So, there is no significant benefit to any amount of WET code, yet it is all too common in software development.
An application ends up with WET code through inefficient programming, which is often a fact of life in enterprise projects. Developers create WET code when they merge different code bases or introduce open source libraries with similar features and functions to a project. Adopt and enforce efficiency standards to curtail code redundancy.
Additionally, any code refactoring endeavor should include identification and elimination of WET code, and the project should reinforce the DRY principle.
Improve code quality and standards
When software developers adhere to code standards, it makes the finished product more efficient and readable to other team members. There are a number of ways to shore up programming standards, in addition to a focus on code redundancy.
Reusable code is a huge assist to developers. When developers reuse code, it reduces the effort and time necessary to build basic app components. For example, development teams often pull code from other apps or open source code for simple functions -- as long as the code is written in a way to make it reusable. Developers can adhere to these practices and principles to maximize code reuse.
Developers can also adopt programming conventions or standards related to various application characteristics, such as maintainability, reliability, efficiency and usability. These guidelines inform developers on how to write good code.
Dig Deeper on Software Development Fundamentals
Related Q&A from Stephen J. Bigelow
While the Windows Admin Center is one way to manage the Azure Stack HCI platform, you can also use traditional, battle-tested tools. Continue Reading
There are many tools available on the AWS Marketplace for QA testing, making it difficult to determine where to begin. What should an enterprise look... Continue Reading
Hyper-converged infrastructure that runs on Windows Server is not a new concept, but Microsoft's Azure Stack HCI program has one big difference from ... Continue Reading
Have a question for an expert?
Please add a title for your question
Get answers from a TechTarget expert on whatever's puzzling you.