Seck dry – Wikipedia, the free encyclopedia

Posted on by

In computing, the design antipatrón lava flow O dry lava It occurs when software is delivered before being completed or before being completely tested and when exposed, it is no longer possible to change its characteristics, such as when a lava flow dries on the outside.

The lava flow antipatron is commonly found in the systems that initially had the investigation, but that ended up producing. It is characterized by the code pieces (lava flows) of previous versions that were scattered by the application code, and now, they are immovable (dry and hardened lava flow) since no one remembers very well for them to serve or if They are used in the code.

This is the result of a previous development in which during the research phase, developers tested several ways to solve a problem, usually, in some type of “career” to issue some type of demonstration, causing this to create a poorly structured code (in the form of spaghetti code) and poorly documented. 

/**  *  * @author fictitia  *  */  public  class  Antigua  {  /**  * When I found this method I didn't have Javadoc.  * I think Pedro did it, but I'm not sure, he is not in the company anymore.  * I don't know very well if we are using it, but it seems to be an important method since it has many  * Lines of code so it is better than anyone touches it.  * The name does not help to understand it either  */  public  void  do something () {  // infinite lines of code  // ....  // ....  // ....  // ....  // ....  // END  }  }

The result of the lava flow is many code fragments, inexplicable classes and procedures that are not related to the rest of the program. In fact, many of those pieces have such a complicated appearance that they make them important.

These codes are not usually analyzed due to the great cost that its analysis and verification has. Really in practice verification and test are rarely possible.

  • Frequent unjustified variables and fragments.
  • Undocumented functions
  • Pieces of code or classes that are not clear that they do.
  • Large blocks of code without explanation or documentation.
  • Many parts of the code with the label “must be replaced.”
  • Obsolete, unused interfaces or inexplicable positions in header files.

Consequences [ To edit ]

  • The system ceases to have an object -oriented design, which implies losing some of the properties they entail. In this case, modularity is lost by being a serious inconvenience for reuse. You can also promote the appearance of other lava flow.
  • As this type of code increases in a system, it becomes much more difficult to document or understand its operation to make improvements.
  • High cost to load in memory, so you can have an important loss of resources which leads us to a deterioration of performance.

Typical causes [ To edit ]

  • A code placed in production with a hurry without being verified or documented.
  • Unique (and little friendly) developer.
  • Implementation of many test methods to add functionality to the system.
  • Failure to comply with the company’s policies regarding the style and documentation of the Code.
  • Little continuity in development teams.
  • Highly repetitive development processes.
  • Constant correction of system functionalities.

One way to avoid the lava flow is to follow a structured and documented development.

When the code is in continuous change it is necessary to remove the outdated parts to avoid dead code.

Once this antipatron appears, the solution is really expensive since it is difficult to know what are the components that are used in a code that you barely know.

It is not always a bad development to follow a little documented and not thought for management structure. In small scale this type of
Mechanism for development and research as it allows you to go faster.

external links [ To edit ]