What are some of the bad examples of code that you have seen? Something you would want to avoid?<p>I'm looking for examples which fall along the lines of "fail to see the forest for the trees".
I feel like this could lead to very opinionated, non-constructive comments/flame, but if were to give you an example, I'd suggest taking a look at Wordpress eco-system. While Wordpress core's codebase has improved significantly over the years, some of the plugins haven't.<p>The top pick goes to WooCommerce, although an open source E-commerce solution on top of Wordpress, it has some terrible decisions under the hood.<p>The top pick would go to mixing presentational logic with business logic. For example, to render a table, instead of exposing an array of objects to allow the developer to loop through it as he/she sees fit, WooCommerce will force you to use a PHP function that renders a table for you and there's actually no way to modify the presentation logic if you wanted to.<p>It's a really fundamental programming paradigm that even top open source companies fail to adhere to.<p>Again, I'm not saying this to attack them or the maintainers behind the code, just my opinion of why I think it's bad quality code while respecting the fact that developers still do take time and effort for us to enjoy something with freedom and zero cost.
It doesn't work, energy follows thought and it makes no sense to focus it on what you want to avoid. Take or leave.<p>That being said, the worst I ever saw was the in-house business nonsense I was paid to deal with as a Java consultant. The worst code isn't open source from my experience, subjecting it to public scrutiny would mean suicide for the companies involved.
An example of bad code that always stuck with me was the flawed CDDB disc id hash algorithm.[0]<p>I was reminded of that short-sighted decision every time I ripped a bunch of CDs and saw how importing song titles was <i>not automatic</i> because a dozen different discs had the same hash ids which resulted in collisions[1]. It ended up creating needless friction for millions that depended on that discid.<p>What's sad is I'm not even sure if one can extract any useful "lessons learned" from it! The programmer that wrote it was not an amateur script kiddie; he had a computer science degree from Uni California. Apparently, he didn't realize he was writing a flawed hash algorithm as he wrote it.<p>One could say that hash algorithms should be "peer reviewed". Well, he got <i>unsolicited</i> peer review that pointed how his homegrown hashing computation was flawed but he <i>ignored</i> the suggestion to improve it.<p>[0] <i>>Ti Kan wanted to use a hash. He could have chosen something like CRC32, which would have given him a 32 bit number, yielding 4 billion unique IDs. Instead he wrote his own hash.
[...]
Ti Kan was made aware (not by me) of this problem back in 1994, and given a script to convert this format into a CRC32-based format, but he rejected it because the deployed base was too big. At that point it was probably in the high dozens.</i> -- excerpt from <a href="http://quimby.gnus.org/circus/notes/cddb.html" rel="nofollow">http://quimby.gnus.org/circus/notes/cddb.html</a><p>[1] <a href="https://forums.macrumors.com/attachments/multiple-matches-jpg.17857/" rel="nofollow">https://forums.macrumors.com/attachments/multiple-matches-jp...</a><p>[2] wiki: <a href="https://en.wikipedia.org/wiki/CDDB#How_CDDB_works" rel="nofollow">https://en.wikipedia.org/wiki/CDDB#How_CDDB_works</a>
Here you go <a href="https://github.com/progwml6/Natura/blob/1.7.10/src/main/java/mods/natura/common/NContent.java" rel="nofollow">https://github.com/progwml6/Natura/blob/1.7.10/src/main/java...</a><p>Tip: If you ever end up in a situation where you have to copy-paste code with minor changes then there is something that you are doing wrong. In this case using arrays and loops would be a much better solution.
How about examples of open source code to learn whats really, really good, together with why it was designed that way? Seems like that would be way more useful.<p>Or examples of projects that did things one way, but later refactored, and why they refactored.
That's a really bad idea. You need to have a good counterexample, otherwise it's just wasting time at the best case. A lot of people learn from really bad codebases and picking up the same style which is terrible. You should look at GOOD codebases instead!
If you’re interested in a case of unnecessary optimization and effort, the infamous left-pad npm library has been refactored to only add to the string O(log(n)) times. It is short but not sweet.<p><a href="https://github.com/left-pad/left-pad#readme" rel="nofollow">https://github.com/left-pad/left-pad#readme</a>
Here's some old code of mine:<p><a href="https://github.com/vatt849/LibMinecraft/blob/master/LibMinecraft/Client/MultiplayerClient.cs" rel="nofollow">https://github.com/vatt849/LibMinecraft/blob/master/LibMinec...</a><p>The whole library is a trip if you want to read a bunch of bad C#. Highlights:<p>- Generated documentation<p>- Giant switch/case instead of a more organized dispatch map<p>- Large swaths of commented code instead of using version control<p>- try...catch statements that just eat the errors<p>- Inconsistent code style<p>- This thing:<p><a href="https://github.com/vatt849/LibMinecraft/blob/master/LibMinecraft/Client/MultiplayerClient.cs#L603-L621" rel="nofollow">https://github.com/vatt849/LibMinecraft/blob/master/LibMinec...</a><p>I've written something similar from scratch since, which I'm still not entirely satisfied with, but is much better for reference:<p><a href="https://github.com/ddevault/TrueCraft" rel="nofollow">https://github.com/ddevault/TrueCraft</a><p>The client-side networking code lives here:<p><a href="https://github.com/ddevault/TrueCraft/blob/master/TrueCraft.Core/Networking/PacketReader.cs" rel="nofollow">https://github.com/ddevault/TrueCraft/blob/master/TrueCraft....</a><p><a href="https://github.com/ddevault/TrueCraft/blob/master/TrueCraft.Client/MultiplayerClient.cs" rel="nofollow">https://github.com/ddevault/TrueCraft/blob/master/TrueCraft....</a><p><a href="https://github.com/ddevault/TrueCraft/tree/master/TrueCraft.Client/Handlers" rel="nofollow">https://github.com/ddevault/TrueCraft/tree/master/TrueCraft....</a><p>Notable improvements:<p>- Handwritten docs only where necessary<p>- Uses a stream implementation for decoding this particular wire format<p>- Has a different and better abstraction for reading packets out<p>Still has bad error handling though.
See Syobon Action it's source code as bad as the game itself.<p><a href="https://github.com/angelXwind/OpenSyobonAction/blob/master/main.cpp" rel="nofollow">https://github.com/angelXwind/OpenSyobonAction/blob/master/m...</a>
The source for Terraria is notoriously terrible.<p><a href="https://github.com/TheVamp/Terraria-Source-Code" rel="nofollow">https://github.com/TheVamp/Terraria-Source-Code</a><p>It is another example of how even inelegant code full of hardcoded values can be successful.
Libraries can be useful despite imperfections, and poor design decisions can occur in overall good libraries. So we can't judge too harshly.<p>Having said that:<p>1) iText PDF library used to have some fairly poor & duplicated code. Column layout was a highlight. Also strange ideas overemphasizing subclasses, eg. for paragraph styles. (Correct approach: use values rather than types.)<p>2) Tomcat webserver back around 2007 used to have some amazing 'clustering' code to deploy your webapp across multiple servers. But it lacked proper knowledge & hence control of what it was doing. IIRC there was no clear master, and a server couldn't tell what had been started on it versus what had been replicated since a peer was seen to be running it. Effect: replication would be additive only, contexts would just replicate everywhere uncontrolled, and there was no good way to stop/ undeploy an app across the cluster.
"How to Make Mistakes in Python" -
<a href="https://www.oreilly.com/library/view/how-to-make/9781492048275/" rel="nofollow">https://www.oreilly.com/library/view/how-to-make/97814920482...</a>
Drupal 6/7 would be an example for "widely used [at the time] but pretty bad". I don't know how many of the issues across all layers were addressed in later versions.<p>OpenSSL is still an excellent example for very messy code where even maintainers / frequent contributors regularly get lost. Also a good example for designing many bad APIs and poor docs. libsodium is a good counterexample, although the internal structuring of the code base is a bit atypical, it is logical and consistent. (It does have some API idiosyncrasies which cater specifically to dynamic bindings, like providing a constant always as a #define/macro but also as an exported function; and it has a bit of an issue where you have both legacy APIs and newer APIs, but the docs are pretty clear on which is which).<p>BorgBackup is an example of how you don't want to mix C and Python code, and also contains various bits that only 1-2 people on the planet really bothered to understand, besides demonstrating other issues of organically grown code bases.
There are an infinite variety of things that you don’t want. If you focus all your energy on those things, then you won’t have anything left to do the positive things you do want.<p>You have to turn that equation around. Even if all you know right now is the negative thing you don’t want, you have to figure out how to reframe that into the positive thing you do want. On,y then can you make positive progress towards that thing you want — and by the way, you will naturally avoid the things you don’t want by focusing on the things you do want.<p>Sure, examples of bad stuff can be instructive, but only so far as it helps you further clarify the good stuff you’re actually trying to achieve.
> fall along the lines of "fail to see the forest for the trees"<p>I think I'm going to need an example to understand this?<p>Having said that, one of the most informative programming books I've ever read was <i>C Traps And Pitfalls</i>. Flags common easily-made errors and explains them, which in turn fixes misconceptions about the language. I feel most languages could do with one.
Here is something atrocious I wrote in Lisp. You actually <i>can</i> make Lisp ugly! Who knew?<p><a href="https://github.com/ksaj/Capitalize.Lisp" rel="nofollow">https://github.com/ksaj/Capitalize.Lisp</a>
Just a side note-- this is the beauty of Open Source. If there is some bad code (we all write it), it can be improved with a little help from Open Source "friends".<p>All of us are stronger than any one of us. Long live Open Source!
Many JavaScript libraries like Fastify (Node.js) for example. You always get a nice & clean API but if you look under the hood you would be amazed at how much spaghetti code can be written in a project.
Praat: <a href="https://github.com/praat/praat" rel="nofollow">https://github.com/praat/praat</a>
I'm not sure that this is a good way to learn anything, however.
Jgit is amazingly bad for a piece of software built on top of well thought out data structures if git. Some if its flaws could be attributed to Java IO design, though.
<a href="https://github.com/mholt/caddy" rel="nofollow">https://github.com/mholt/caddy</a> not only a mediocre code, but the guy behind it received lots of money from Mozilla as an innocent promising open source project author, then he made it as a paid product.