devRant - A fun community for developers to connect over code, tech & life as a programmer

OK, listen, this is not a lie.

For every sentence here, i collected a valid evendence i can show to proof, should you refuse to believe the sentence to be correct. Not one of the sentences down there is opinion but provable fact.
All of this is not a compendium of all mistakes i ever seen, but it is all present in ONE project:

- The codebase isn't a well thought out structure. In fact, it doesn't follow any defined standard, but is, instead, a bunch of spaghetti code. (provable by the fact that every class is public and globally visible)
- Where every one who worked at, failing to find or understand the existing code, added his personal universe of tools and objects. That despite that every class being globally visible. (provable by finding multiple implementations for same things)
- Also, it is remarkable that this happend even though the code is mostly young, the oldest parts only 3 years old and it still follows some or most of the major antipatterns there are. (provable by this was when the project started)
- There was not once a refactoring task issued in the runtime of that project. (provable by refactoring tasks not existing)
- Justified by just wrong reasoning like "it's optimised for mass data", or "it's how we work here, because it's always worked", the code does not follow
any design principles, let alone Michael Feathers and Robert C. Martins S-O-L-I-D principle, which is, while being taught and studied, improved and used in the rest of the world,
not even mentioned in one of the over 3000 pages of documents. (provable by full text search and asking the programmers about SOLID)
- Also, there is no state of the art Software Design process (provable by not having product owners, not having requirement engineers, nor design tools for that)
- nor is there distinction between business process and software solutiong in documentation, which, by the way has over 3200 pages (provable by having the functional documentation mixed with implementation details and process descriptions)
- There is no dev ops in place.
- Not a single Unit test has been created.
- The Code Inspection that could run at check in has been disabled.
- There is no dependency graph between packages
- There is no branching or encapsulation of changes nor association between code change and respecting task
- Everyone who works with that legacy code, where such a lot of things are not determinable, your check ins are a shot in the dark, provable by a direct correlation between commits, shortly followed by one-line commits to the same task.
- Also, it is internally communicated and believed there, that this is a high-end, object oriented, state of the art way of getting things done.
- Just yesterday, we stated an effort of 9 days (3 people work 3 days each) do let a modal dialog save the changes when coming back with OK Result.
- Also, training the existing programmers into transitioning to better software architecture and SOLID concepts is considered low priority because of it being too expensive