The worst code collection ever

[[141823]]

In fact, there is no such thing as the "worst code in history". If there is, it is only "worse than ever". I want to talk about this topic casually, which also originated from a discussion on Douban. In fact, it is common to be criticized for bad code when the system is complex. Of course, there are also some short code snippets that are enough to show that the author of the code is not a good person.

The use of Boolean types can easily become the worst code:

 if (isTrue())
 if (isTrue())
 doSomething(); 
 
 if (boolVal == true ) {
 .....
 }

There are some meaningless comments:

 return   1 ; // Return 1   
 
 //If the flag is true, return true  
 if (flag)
 return   true ;

Even more meaningless is variable naming like this:

 public   static   final   int ONE = 1 ;
 public   static   final   int TWO = 2 ;

Some people also say that the worst code snippet should be like this:

 }
 }
 }
 }
 }
 }
 }
 }
 }

There is also 12306.cn, which was once criticized to the point of pus flowing all over its body. The code excerpt is:

 var sig = 0 ;
 if (searchwordl.indexOf( "'" ) > - 1 || searchwordl.indexOf( "\"" ) > - 1 || searchwordl.indexOf( "%" ) > - 1 || searchwordl.indexOf( "#" ) > - 1 || searchwordl.indexOf( "&" ) > - 1 || searchwordl.indexOf( "*" ) > - 1 || searchwordl.indexOf( "(" ) > - 1 || searchwordl.indexOf( ")" ) > - 1 || searchwordl.indexOf( "@" ) > - 1 || searchwordl.indexOf( "`" ) > - 1 || searchwordl.indexOf( "/" ) > - 1 || searchwordl.indexOf( "\\") > -1 || searchwordl.indexOf(" , ") > -1 || searchwordl.indexOf(" . ") > -1 || searchwordl.indexOf(" = ") > -1 || searchwordl.indexOf(" < ") > -1 || searchwordl.indexOf(" >") > - 1 )
 sig = 1 ; 
 
 searchwordl=searchwordl.replace( "'" , "" );
 //searchwordl=searchwordl.replace(" ","");  
 searchwordl=searchwordl.replace( "%" , "" );
 searchwordl=searchwordl.replace( "#" , "" );
 searchwordl=searchwordl.replace( "&" , "" );
 searchwordl=searchwordl.replace( "*" , "" );
 searchwordl=searchwordl.replace( "(" , "" );
 searchwordl=searchwordl.replace( ")" , "" );
 searchwordl=searchwordl.replace( "@" , "" );
 searchwordl=searchwordl.replace( "`" , "" );
 searchwordl=searchwordl.replace( "/" , "" );
 searchwordl=searchwordl.replace( "\\"," ");
 searchwordl=searchwordl.replace( "," , "" );
 searchwordl=searchwordl.replace( "." , "" );
 searchwordl=searchwordl.replace( "=" , "" );
 searchwordl=searchwordl.replace( "<" , "" );
 searchwordl=searchwordl.replace( ">" , "" );
 if (searchwordl == 'Please enter the search criteria' ){
 alert( "Please enter search criteria" );
 return   false ;
 }
 if (searchwordl == '' ){
 alert( "Please enter the search terms correctly" );
 return   false ;
 }
 if (sig == 1 ){
 alert( "Please enter the search terms correctly" );
 return   false ;
 }
 document.getElementById( 'searchword' ).value=searchwordl;

There are also bad JavaScript codes, which are too many to post. The more flexible the language, the more difficult it is to control, and the more likely you will see super bad code.

Tiago Fernandez did a poll to elect the worst Java API:

 The formula is: score = (I can live with) + (Painful * 2) + (Crappy * 3) + (Hellish * 4) 
 
 The result, did you guess it?

Java has many frameworks and strict syntax, which is helpful in limiting programmers who want to cause damage. But if they really want to cause damage, it is impossible to limit them. I once worked on a portlet extension class with several thousand lines in total. At that time, I thought the code was bad enough. But later, I saw a stored procedure with more than 5,000 lines and a jsp page with more than 7,000 lines. I used to think that Java programmers were much less destructive than C/C++ programmers. It seems that this is not entirely true.

The most common types of bad code I have encountered include the following:

Some naming habits, such as the abbreviation "cptct" for method names that are almost cipher-like, are probably due to the poison of Basic. Even early versions of Visual Basic enforced some constraints on the code (such as the length of variable names, the number of variables allowed in a module, and the size of the module).
Web projects in the early years (even some of the web projects done by small companies now) did not understand decoupling and layering, and all the logic was mixed together, like a pile of shit. Page templates directly accessed the database, style codes were scattered all over the world, and HTML was hard-coded in various logics.
In the eyes of some programmers, "reuse" == "inheritance". As long as there are reusable properties and public methods, they will try to use the invincible thunderbolt inheritance method to solve it, regardless of whether it is suitable or not, level by level, in the end it must be a majestic and boundless inheritance tree.
Endless tool classes. This type of code is not much better than the inheritance code. Static classes like XXHelper and XXTools are everywhere, but the reuse vision is more than just inheritance...
I have seen several programmers like this who have almost no idea about the definitions and methods of numerical object types such as Integer, Long, and Double, but are very familiar with String. They convert and verify data into String and then convert it back after completion.
God class. The essence is a misunderstanding of the single responsibility of a class. It's fine for Java and C++ programmers to write God classes, but this year I heard from a friend that a Ruby programmer with considerable work experience wrote a huge God class...
Design patterns are everywhere. The essence is over-design. A good "new Template()" must introduce a factory, and then a strategy pattern and template pattern. It's not enough, so finally add annotations to achieve it...
Most of the JavaScript and CSS. Not explained.

Today, a colleague said that the reason why code becomes bad code is that the person who wrote the code will encounter many more problems than the person who reads the code later. Although the person who wrote the code solved most of the problems, the remaining problems are enough to make the code infamous. But I don't think so. I have seen VB code and Delphi code from a relatively old year. Although they are all used for interface development and many of the concepts are far less than today, the code is still clear and easy to understand.

Some programmers say that the deadline is tight, the project is heavy, and the leader is pushing me to the point of vomiting blood every day, so I have no choice but to write bad code. There are thousands of objective reasons, and I really have nothing to say. After all, when material civilization is still very weak, it is better not to talk about spiritual civilization. However, excellent programmers have pursuits, but people are numb and always talk about project pressure. Giving a loose deadline may not make a difference.

Some programmers also said that dialectical materialism tells us that everything has two sides, so we should learn the good design from bad code and take the bad design as a warning... I said, come on. Bad is bad, even shit in an ice cream cone is still shit, so why be so pretentious?

Many programmers always have the urge to start over, especially when they see bad code. I used to do that too. In fact, this is dangerous. Moreover, in many cases, your rewrite may not be better than the original bad code. Maybe you can solve 30 problems, but introduce 50 new problems. Refactoring should start with small changes and modules when the business model and process are clear. It is always dangerous to make big changes.

I don't admire programmers who always say they suffered so much fifteen years ago. I admire excellent programmers who can still write code that makes people feel comfortable now under the conditions and concepts fifteen years ago. Not writing bad code is to cherish life, save resources, and protect the earth. Writing good code is the quality of a programmer. There are no so many reasons to explain.