working on an android app. the guy who wrote it is a complete retard designed it and made it overcomplicated and unmaintainable now no one can change anything without breaking all that shit ... found this comment, someone else tried to do it and failed miserably apparently.

Pointy Haired Boss: "There's an issue with this simple bit of that service, could you take a look?"
Me: "Sure, give me a minute to investigate"
*A minute later*
Me: "No wonder there's a problem, this code is horrendous! What idiot wrote this unmaintainable crap?"
PHB: "Doesn't matter, just fix it, test it and release it."
Me: "I just want to check who did it, so they never touch our code again."
*Checks SVN log*
Me: "Well, I guess I can never touch our code again."

We called it "Project Hindenburg".

A huge planning and logistics app with hundreds of screens and dozens of interwoven subfunctions, suddenly needed to be able to support multiple time zones. Our project was to retrofit every area that touched on dates or times, to allow the user to specify, and work in, any time zone.

At this point in the story I can tell whether you have had to work with time zones in code. People who haven't are butting in with something that begins, "that should be fairly simple, you just need to..." followed by some irrelevant noise that betrays their ignorance.

People who have worked with time zones are nodding in shared pain, like fellow attendees of a survivors meeting.

You see, programmers tend to think of time zones as arithmetic; in reality, they are confusing, ambiguous, chaotic, and individual. You can't translate everything into a central time zone (eg UTC) because you lose the user's intent. For example, if you schedule a meeting for 3pm and then move it to the next day, you want it at 3pm even if the clocks have changed.

Project Hindenburg ended up using the entire development staff of the company for well over a year. It smashed our release projections to rubble, made an already tangled code base completely unmaintainable, introduced mind-bending edge case bugs that reduced staff across the company to tears (literally), and led to most of the mid-level and senior developers eventually quitting (including me).

I am @fuckfuckityfuck, and that was the story of Project Hindenburg.

Name your stuff in English. Variables, functions, files. Everything.

You make the code completely unmaintainable for everybody that doesn't happen to speak your language otherwise.

I cringe every time I see someone in our company use German in his code. Just don't.

Hello there, just couple of words about PHP. I've been develop on PHP more than 10 years, I've seen it all 3,4,5,{6},7. Yes PHP was not good in terms of engineering and patterns, but it was simple, it was the most simple language for web to start those days. It was simple as you put code into file, upload it via FTP and it works. No java servlets, no unix consoles, no nothing, just shared hosting account was enough to host site, or even application with database. As database everybody used to have mysql, again because its simple to start and easy to maintain. So PHP+MySQL became industry standard on Web during 00-2012, and continues in some way.
You can write HTML and logic inside single file, within php code, even more single file may content few pages, or even kind of framework. That simplicity and agility sticks everybody who wants to develop sites with PHP.
This is pretty much about why it is so popular.

Each good or wannabe PHP developer in an early days write its own framework or library (like in javascript this days because of nodejs)

Imagine that PHP has hadn't have package manager, developers used to have host packages on their own sites, then various packages catalog sites created, and then finally composer. A gazillions of php code had spread over internet, without any kind of dependency control. To include libraries to your projects you have to just write include, or require. Some developers do it better than others.

So what we have ? A lots of code, no repositories, zip archives with libraries, no dependency control.
Project that uses that kind of code are still alive even today, they are solid hose of cards, and unmaintainable of course.

And main question that I'm trying to answer is Why PHP is not good ?
- First is amount of legacy code which people copy and pasted into their project, spread it even more like a virus.
- Lack of industry standards at the beginning lead to a lots of bad practices among developers. PHP code usually smells.
open source php projects in early days was developed in same conditions so even in phpbb, phpnuke, wordpress, drupal used to have a lot of bad practices in their codebase. So php developers usually not study by another library, instead they write their own frameworks/libraries.
- "It works", - there are no strong business demands, on web development, again because lack of standards, and concerns.
This three things are basically same, they linked to each other and summarize of answer of why PHP have strong smells and everybody yelling against it.

Whats is with PHP nowadays ? Of course PHP today is more influenced by good practice of webdev. Composer, Zend, Laravel, Yii, Symphony and language it self became more adult so to say, but developers...

People who never tried anything except PHP are usually weaker in programming and ecosystem knowledge than people who tried something else, python, perl, ruby, c for instance.

Summary

PHP as any other programming language is a tool. Each tool has its own task. Consider this and your task requirements and PHP can be just good enough solution.
"PHP is shit" - usually you heard that from people who never write strong applications on PHP and haven't used any good tools like Symphony or Laravel.
Cheap developers, - the bigger community, the more chance to hire cheap developers, and more chance to get bad code. That can be applied on any other language.
PHP has professionals developers, usually they have not only php on scope.

That's all folks, this is very brief, I am not covering php usage early days in details, but this is good enough to understand the point.

Enjoy.

Don't get me wrong, I like funcional programming, but this smug „This would neeever happen with FP“ bullshit really gets on my nerve and kind of turns me off the idea of ever wanting to work with FP programmers.
It's just another paradigm, it's still possible to write unmaintainable fuckugly crapcode with functional programming.
And it is still very possible to write beautiful, clean, well maintainable code with OOP. Get over yourselves and understand that it's a tool and not a religion, and a good dev should know when to pick which tool for which job without childish notions of intellectual superiority.

The nightmare continues.

Currently dealing with a code review from a “principal” dev (one step above senior), who is unironically called a “legendary dev” by some coworkers. It’s painfully obvious he didn’t read the code, and just started complaining and nitpicking.

It’s full of requests to do things that make absolutely no sense, and would make the code an unmaintainable mess.
• Ex: moving the logic and data collection from the module’s many callers into the module instead of just passing in the data.
• Ex: hiding api endpoint declarations by placing them in the module itself, and using magic instance variables to pass data to it. Basically: using global functions and variables instead of explicit declarations and calls.
• Ex: moving the logic to determine which api endpoint to use, for all callers, into the view.

More comments about methods being “too complex” (barely holds water) right next to comments saying “why are these separate? merge them together!”

Incredulously asking how many times I’m checking permissions and how ridiculous it all is. (The answer? Twice.)

Conflating my “permissions” param and method names with a supposedly forthcoming permissions system overhaul, and saying I shouldn’t use permissions because my code will all have to get rewritten. Even if that were true, and it’s likely not, the ticket still needs to use the current permissions. I can’t just ignore them because they might be rewritten someday.

Requests to revert some code cleanup because the reviewer thought the previous heavily-nested and uncommented versions (with code duplication) were easier to read. Unsurprisingly, he wrote them.

On the same ticket, my boss wants me to remove all styling and clientside validation, debouncing, and error messages from a form. Says “success” and “connection failed” messages are good enough. The form in question sends SMS and email using arbitrary user input for addresses. He also says it shouldn’t be denounced on the server, and doesn’t want me to bother checking permissions. Hello, spam!

Related: the legendary dev reviewer says he can’t think of a reason why we would want to disable the feature for consumers, so I should remove the consumer feature flag.

You can’t make this stuff up.

Nah, we leave it to the next guy and start making more babies.

Having to review an offshore C++ codebase made in Romania that the company I worked for they bought to control a wifi module on a complex RF mobile tech device that I can't legally give more details on.

If I could legally post this masterpiece, or should I say masterpiece-of-shit, all of you C++ dev would instantly get AIDS and all the existing types of cancer upon browsing it for 2 minutes.

It's laughably bad and unmaintainable. One of my colleague called it "the perfect example of human obfuscation" and it fits perfectly.

Think of a 100k LoC main function with nested loops and ifs with random sleep values, 1000 values of hardcoded 32 bits arrays declared globally in the first 10k lines for unknown reasons. Comments in Romanian mixed with english. Somehow, this shit works by some miracle.

The worst intern you can think of, while being piss drunk, could do better and it's no joke.

Six years ago I created a drupal page pro bono for an organization I'm in. Was my first site really, was hacky af, in retrospect, I created an unmaintainable monster. And as it usually happens, I moved away, the site stops being properly maintained, opening admin view just cries "please update me" (or was it "kill"? Not sure here). Now I'm back in town and get a call from the current one in charge requesting a training. I thought this evil dark dev history of mine is now finally returning to hunt me forever. But no, she actually understood it, and after half an hour she was perfectly capable of maintaining the site. I'm stunned.

For me, the worst co-worker is one who works by the principle of quantity over quality or a person who thinks quick and ugly fixes are a valid way to solve problems. Also: If there are unittest, don't fucking dare to change or remove them, just so your code runs without errors.

But in general, I just can't work with people who don't really think about what they are coding, people who just code straight ahead without making the simplest plan about how to solve something. Most of these people realize too late, that their approach was rather shitty, unreadable and unmaintainable.

I often see memes about "I forgot what I coded last [insert timespan here]". Though it is kind of normal, if it takes you too long to find out what you wrote, you should consider overthinking your coding approaches.

Just my 50 cents.

Damn I miss coding... 4 weeks of learning & exams is too long...

Blamed team member for writing unmaintainable code. Turns out it was the other way round.

Account manager: "We somehow managed to take unmaintainable spaghetti code for money again. This is a great opportunity for you."

I hate UI design. When you code functionality, you either make a thing work or crash, efficient or unefficient, reliable or unreliable, maintainable or unmaintainable; but in UI design there's by no means an established way to make something look pretty and that pisses the crap out of me. You cand spend countless hours working in UI design, using the latest CSS libraries and frameworks, but at the end, any client can easily say it's crap no matter how cool anyone else think it looks. UI design sucks.

>be my team
>developing a mobile app
>I'm responsible for developing a "RESTful" API to interface communications between the app and the database
>there's also an "admin" web application which the client themselves will use to manage some shit in the database
>I've developed the API, it works with the mobile app
>instead of just making it simply a front-end app that makes requests to the API like the mobile app does, the guy responsible for the admin app completely ignores my API and implements his own with a certain messy dollar symbol language and a certain bloated piece of server software, accessing the same database directly, and does some operations in his own special way that will break what I've implemented
>now data inserted via admin app is inaccessible to the server API, and I'm expected to "fix" my code so it's consistent with this guy's shit, but the only way to do it is introducing interdependency between the actual API and the admin app's back end

Fuck my life, now I'm the one responsible for the app being broken because no way the guy who's used to kludging unmaintainable shit together fast would ever fuck anything up

My boss insists in develop the most unmaintainable ways possible like hard coding everything... EVERYTHING....
DDD (despair driven design)
😵😨

After finishing a long and arduous refactoring I got to delete some hundreds of lines of really horrible, unmaintainable and broken legacy code. Feels absolutely great.

I love the smell of deleted code in the morning.

Annoys me so much how obviously lazy my department has been with one of its products. We have an iPad app that does document management and eForms and stuff. Its not perfect but not the worst. Then they decide they need to build an app to handle a specific kind of eForm. They just went "well this app already does eForms so lets just adapt it".
Worst. Decision. Ever.
the app is simply a branch off the original app. despite being a completely different product which isnt even concerned with the same business objects. it has been hacked until it does what it needs to. And i have to somehow maintain this trainwreck.
As a result we have a branch in our main Git repo that contains a completely different product, which is basically an iOS wrapper for an HTML eForm with ~5000 lines of jQuery to further hack on the functionality that the eForm provides.
And they wonder why iOS developers have been leaving and some keep threatening to leave. Even the Delivery Manager wants us to just do what is needed and get it out the door and never look at it again. How are we supposed to care when thats the attitude of the people who are supposed to be invested in it. Im surprised the client hasnt told us to get lost the app is so hideously broken and unmaintainable. Performing an action on the form can break a completely unrelated section somewhere else. We have lost control.
And they just keep adding more scope, ignoring our concerns cos hey its too late to just start changing the whole approach of the solution.

Do one thing... That's where the trouble starts.

Yeah. Architecture and separation, these are the foundation.

If you don't do these two in a proper and sane way, you most likely end up with the rotten pile of shit most companies call micro services.

Hot glued unmaintainable mess of deprecated shit stapled together by a custom framework abomination cause no one gave a flying fuck to properly design it.

I see these things daily.

I write the reminders every week.

"Hey, lil retarded dev, you don't need that dependency, you can just use languages feature XY added in version XY"

"But that's how I always did it"

Moments where you want to apply violence from the category "inhumane".

Or even more retarded: Yeah it does everything that was written in that one epic that took 6 months with 30 devs to finish.

I sometimes really wonder how some people managed to survive till they got the job. Parents must have been pretty vigilant 24/7...

In reply to atheist in another rant ;)

Here we are, three years later. Our system breaks down at the slightest load. An architecture is hardly recognizable anymore. The code consists of methods that have been refactored beyond recognition. The so-called architects came and went, leaving behind an ever-growing fiasco. Wrong decisions are concealed, criticism of them dismissed as ignorance. Our clients are on the verge of having us all killed. Daily crisis meetings are the norm. The remaining developers skulk around the unmaintainable code like emaciated ghosts. Everyone who has even the slightest chance to escape takes a parachute. Our dailies are made up of lies to cover up yesterday's lies. Our Mondays have become days of dread, because that's when the weekend disaster news has to be analyzed. Yet there are still developers who turn a blind eye. Who recommend this and that workaround in a good-humored tone. The code consists only of workarounds. Sarcasm has replaced any normal discussion. Reasonable suggestions on how to basically refactor the whole thing are rejected for cost reasons. In the process, our entire budget is eaten up by maintenance costs. Middle management should be put up against the wall. Why am I still here? This deceptive feeling that one could still turn the tide. This is eating me up.

One thing my dev years have showed me through various systems:
The world is held together by masses of scripts. And most of them are horribly bad, unmaintainable, extremely complex and usually not replaced on requirement changes, but extended by other terrible scripts to get the desired behaviour.

Windows is based on tons of shitty batch scripts, powershell madness, WSH bullshit and VBS absurdity.
GNU/Linux is build upon trillions of incomprehensible shell scripts, heaps of python gizmo and perl mysteries.
Every complex system I've seen uses batch or shell scripts to fire up its runtime.

And it doesn't seem to get any better, so let's face it, we're doomed.

My biggest challenge has been moving away from an unmaintainable Java/Tomcat/Spring Security application server to a Node.js/Express application server. That handles single sign on and two factor authentication. In 2 weeks.

I'm a front end dev. I'm sure it's fine 😓

I'm so sick and tired of people feeling threatened when improving upon their shitty code! I'm here to do a job and I enjoy my profession.

Don't take that away from me by wasting my time making me say every fucking time that I come from a good place and that I just want to provide a better solution AND not create fucking mess that will have to be rewritten when some ninja bugs occur because of completely unmaintainable crap nobody can understand. Holy shit!

I couldn't care less if you're 10 years in the company. I see that all the good devs left after dealing with your shit every God damn day.

I'm not here to deal with your insecurities and couldn't care less about pointing fingers! I just wanna do better and not write same level of quality over and over again!

You're not getting bonus points from me by sitting on your ass all day and half-assing everything you do with some lame ass excuse.

So no LGTM from me when it's utter error prone shit!

So if you don't wanna help, just get the fuck outta my way and don't waste my time! Jeeez

If you're working on close to hardware things, make sure you run static analysis, and manually inspect the output of your compiler if you feel something's off - it may be doing something totally different from what you expect, because of optimization and what not. Also, optimizations don't always trigger as expected. Also, sometimes abstractions can cost a fair amount too (C++ std::string c/dtor, for example, dtors in general), more than you'd expect, and in those cases you might want to re-examine your need for them.

Having said all that, also know how to get the compiler to work for you, hand-optimization at the assembly level isn't usually ideal. I've often been surprised by just how well compilers figure out ways to speed up / compactify code, especially when given hints, and it's way better than having a blob of assembly that's totally unmaintainable.

Learnt this from programming MCUs and stuff for hobby/college team/venture, and from messing around with the Haskell compiler and LLVM optimization passes.

Fuck, I knew that my code for my thesis would at some point become bad and very unmaintainable. Workaround here and there, everything put together "to fix later", just to make it all work "for now". I know what my code does where and when but my tech debt has reached a critical point, where a new idea and new procedure cannot be simply be added. Well, time to refactor and modularize as much as possible😪
Wish me luck that the whole project doesn't brake. Oh and of course so many different changes that I don't know what to put in git and in which order to do so.

The worst co worker I had is actually pretty recent. He joined a well integrated team on what was basically a legacy project. He sounded like a good developer and seemed to know his stuff but it took him ages to push out fixes/features. They were always massively over-engineered, poorly named, partially tested and what documentation he did write still managed to bitch about how poor the project was structured.

He spent most of his time bitching about the general shitty nature of the project (he wasn't wrong) and the lack of interest from other Devs.

He was so unpleasant in interpersonal communication that by the end no one would work with him.

In his last team meeting he basically said he was glad to be going and that we were all lazy, disinterested and shouldn't consider ourselves his peers. The equivalent of storming out of a party after setting the couch on fire and shitting in the sink.

We've since removed all his overcomplicated, not standard, unmaintainable code.

I'm faszinated by some dev's ability to write legacy code.
Not maintaining but plainly creating code so horrible, that it can be considered legacy.

I wrote a new API for a silly Application because the old one had hardly anything to do with rest. At all. And despite the code being only 2 years old, it was still unmaintainable.

Now that I'm finish with this task, i got the next generation of the angular Frontend.
A guy wrote a completely new version of the frontend in angular5.
Only untyped variables, no documentation, no tests at all, no idea whats going on where,....

I thought my job was to adjust a few URL's and change some DTO's, but now i have to refactor everything again...
And the pain continues.....

Most of my private code is created in the evening hours and after one to two beers, so I got that covered pretty well - though if you want to see what happens if you code literally shitfaced, just go play Mafia 3. That deterred me from trying.

The one thing I did at a party was fix a computer after (I think) 4 beers. Apparently I got it together because the sounds worked after that, but don't ask me how. Besides, it had OSX, I usually avoid that thing like the plague. I guess getting drunk means I can handle even that shit.

1-2 Beers is the max I still can code (or properly think) with. Any more and I can't get a single line out.

Worst thing I tried was coding high. I was on a short trip to Amsterdam and a friend of mine brought on some White Widow...

Yeah, I could focus alright... The code worked and the program was done in two hours (It was an exploit for... well, lets not get into details here).

When I reread the code while not high anymore, it might as well have been binary (it was Python). I could, for the life of me, not figure out what the hell I had been writing there or how/why it worked - but it did its job.

Never again. I mean, WW is my favourite and I hear a lot of artists use it to enhance their "flow" when creating art...

I guess it makes sense to code on that, but I generally try to avoid flow when coding - it makes you produce unreadable and unmaintainable code.

I reported to our team leader (who is not a developer) that me and my colleague has been having problems with our senior developer whose codes are unmaintainable and messy. I told the team lead that I am losing my trust towards my senior developer and that his codes are messy and not following the coding standards. I was nervous at first because this certain team leader is tight with the senior dev. But still, I expected the team lead to be objective.

I was surprised because the team lead asked me if 'I was perfect' and then the team lead continued to shift the conversation towards me. Team lead then started to compare me with the senior dev which is unfair because I've only been working for 2 years whereas the senior developer has been doing this for 6+ years. Team lead said that I was arrogant. Team lead sent our convo to the other teammates and friends. Team lead told me that I am such a baby.

Fast forward, the senior dev talked to me. Told me that he was busy so he didn't get to improve his codes. Which I dont buy because I often see his discord status as playing during work hours. Told me that it wasnt him. Which I dont know if i should believe since he always lies. Told me that his knowledge is outdated. Told me that maybe because I came from a good university and he did not. He apologized and told me he will improve. Sounds good right?

It's a lie. Because then my friend gave me a recording of his voice ranting about me after our talk. In that recording, he said that I have nothing to prove so I dont get a say. He said that he doesnt care about me. He said that I am cocky. Which I dont understand. I only commented abt his work, why is he attacking me personally? Plus, if someone new like me already already noticed the flaws in his work, what does that say about his skill?

My teammates then asked me to just take the fall lol take note that these teammates were also complaining about this senior dev. they asked me to just give them what they wanted to hear. That I am the one who's wrong and the bosses are right. I said I wanted to defend myself but they hated me for that. They told me to think about what would happen to them. They told me I am selfish. Is it selfish for wanting to defend myself?

I defended myself. I told the senior dev that my intentions are for the right reason. He told me he understands. Later that day, a friend told me he talked behind my back again.

Senior dev told me that the team leader cried because of the words I said. Which i found confusing because it was my own feeling, my own opinion that i am losing trust with this certain senior dev so why would the team lead be so affected by that? Also, i showed our convo to the most objective people i know and they said that i didnt say anything that is offensive nor arrogant I have no control as to how people would react to the words I say. It's beyond me.

I feel so helpless. I told those things to the team lead because I think a team should be open to each other but I was blown out of proportion instead. My friend told me that the team lead and the senior dev are still talking behind my back.

If they do this every time someone tries to speak up, will they ever grow?

I'm so sick of "senior/lead" developers pretending they know how to write tests and ending up with these unmaintainable test suites, full of repetitions and incomprehensible assertions.

You should take some time to learn from your mistakes instead of just continuing to write the same shitty tests as usual!!!

Every time I arrive at a new team I spend weeks just trying to understand the test suites for what should be fairly SIMPLE applications!

UNIT TESTS SHOULD TEST UNITS OF CODE!
If your unit test tests seem to be repetitive, they are not unit tests. Repetition is expected in integration tests, but that is why those are usually DATA DRIVEN tests!!!

R.I.P John Doe

He made the mistake of writing unmaintainable code then leaving the team.
I just heard of his passing.
He was brutally beaten to death by the new maintainer. Now the maintainer is behind bars.
And now I've been asked to maintain it.

R.I.P Me as well I guess

Joke of course.

Pet peeve: the claim that static typing prevents errors.

Today I worked on a C# project that's a mess of nulls, side-effects, inferences, and race conditions. Then I went back to a JS project that's twice the size but written in a clean, well-tested, FP style and currently has fewer than 10 issues logged.

Look, I get that there are upsides to static typing, and I'm open to introducing typescript or flow for our JS code.

I just can't stand the faux-concern from the static typing dingleberries when they are the ones who produce these horrendous lumps of unmaintainable shit, and the JS/Python/Ruby/etc people are over here quietly reinventing functional programming and code modularity.

How to write unmaintainable code and keep your job for life, tip #476;

Use A.C.R.O.N.Y.M.S. to keep the code terse. Real men never define acronyms, they understand them genetically

Today our so called "architects" chose the most complicated, most unmaintainable, prehistoric way to handle a simple, really easy REST problem...they stood around the white board, marveling at the alleged brilliancy of their imbecile drawings and tried to show us low life devs how we should implement this or that idiotic aspect of their crazy solution. We looked at each other desperately, raising our eyebrows at each new wave of insanity. No one spoke up...that includes me. I feel shit right now. Implementation sprint starts tomorrow. Thinking of grabbing a life vest and jumping overboard right now. Our customer will strangle us for this wannabe crap and I am already scared having to show the resulting API to them.

From such a healthy environment this job turned into an extremely toxic one. Now i finally understand how a toxic environment looks like. It's extremely disgusting. Putting 5 tasks on my name to work in parallel and as i work they put 2 more. All High priority tasks. It is physically impossible. The scrum master whore told me to just check the code how to do something to users and understand this for monday so i can help QA guy to test it. I went over the code with a colleague and understood it. Today she screamed at me angry i didnt do the task. What the fuck are you talking about? I checked the code and im ready to do help the QA guy test it whenever necessary. Then she talked shit changing the task that i was supposed to not only understand the code but also do the task on Monday and now its the end of tuesday and its not done. Fuck you. That was not what she said initially. Its very Fucking confusing. Then she said to QA guy i give up i cant handle it with this guy sorry but ill have to report this to product owner. So be it. I dont give a fuck. I am ALONE working on a GIANT, unmaintainable, spaghetti, caveman technology codebase with broken outdated or nonexistent docs, nobody to help me, the colleague whos supposed to guide me is a good guy but overloaded with tasks himself so he doesnt have time, i him and many of us requested another person to join to work with me on same role but they dont have the budget which is a Fucking lie, a client worth trillions of dollars does not have a budget, yeah get fucked retards. This suffering and downfall of your project is mostly their fault. Theyre too arrogant and proud to understand or admit that it's not possible physically for 1 person to manage and keep knowledge and code on 7 tasks per day. All that for Fucking $8 an hour?????????? I hope cancer eats all of u. Every single one to the very fucking bones till ur bones break. This is fucking disgusting and sickening. Right when i was supposed to get paid $17 an hour (and thats gross income not even net.....) I am now fucking forced to quit this shithole toxic job. Because i realized no amount of fucking money, not even before-tax-$17-an-hour money is worth the weight of stress that i get punched with every fucking day. No fucking job is worth more than health. This is saddening and depressing extremely. All of my fucking plans are ruined. The car to buy on leasing--ruined by a whore. The 2 day vacation this week--ruined by a whore. Going out with my hot blonde gf during this miserable 2 day vacation--ruined by a whore. Meeting with 2 american clients I've been in touch with for several years to work on a side project--ruined by a whore, meeting canceled and delayed due to my overtime work. I am literally fucking treated like the Moscow Crocus Hall terrorist. They have no fucking sympathy or understanding for how fucking HARD this fucking DevOps job is where i work on a 30 year old legacy codebase with no fucking help. It is simply not possible. Now its a race between who's gonna fuck who: either i quit first or they fire me first. At this point its not a matter of if but when. Surely soon enough. Cant wait to get the FUCK away from these pieces of shitheads. I either have option to cry and go mentally insane by giving it my all until i fix the task on time but the stress i would get for that would need them to pay me at least 9 mill $ a year. Fuck with someone else you fucking retards. You're using slave labor to work for basically free just so u can profit a lot. Literally on the meeting one of their bosses said they get 50% of margin which is a lot in biz world for tech field. This is absolutely sickening and saddening that im treated like a fucking terrorist. Fucking Disgusting. Cant wait to not Ever fucking work in this toxic fucking place. Quitting by max 1st of april.

Talking with my dad about a program he's been working on at his company. He doesn't work on it directly, he works with parts on the side to show to clients. He's basically a sales rep that shows some cool features.
Me: is this that the program where it converts scanned items into readable text?
Him: yes but it does a little bit more than that.
*promptly goes into detail about how it works*
Basically merges documents together based on some criteria that it needs to meet. There are 5 cases and all of it is coded in sql, the 5 cases aren't coded based upon logic but based on each possible outcome of a scenario. And it would brute force it's way to a solution. The way he explained it made me think it was just mountains of spaghetti code.
I couldn't help but think something like this
00000
00001
00002
00003
It just sounded messy. And I haven't even looked at it.

Me: 😬 why would you design it that way?
Him: because it works.
Me: but the code has to be so unmaintainable
Him: well I don't have to look at it full time.
Me:... (flawless logic... But why¿¡¿¡¿😢)

you don't need a cms for everything. just use md and git instead of coding unmaintainable plugins for cms that stop working after upgrading to the next major version

At this point I fucking hate my project. After 3 months I literally can not concentrate, I am just staring on a screen, smashing my hands on the keyboard and praying that it will fucking work without bugs. At this point it still works pretty well. I am so sorry for everyone that will have to work on this after I leave. According to the project leader it should not take more than 20 more hours. Hes a really cool guy, but if he's going to talk optimistically about this fucking project once more I am gonna rape his wife and his dog. Last fucking time he said that its just 2 already implemented features that just need to get connected together, I spent 30 hours rewriting half of the codebase because how inconsistent and shitty the code was. I am not fuckin suprised that we are going to rewrite whole shit from a scratch, because the code is already unmaintainable. Wish me luck, because I really need it to survive another week working on this trash.

Making sure you can't be fired 101:

The docs for your code should closely resemble that creative writing assignment you turned in a week late in college.

When Do You Stop Taking Responsibility?

Let me clarify by describing four scenarios in which you are tasked with some software development. It could be a large or small task. The fourth scenario is the one I'm interested in. The first three are just for contrast.

1. You either decide how to implement the requirements, or you're given directions or constraints you agree with. (If you hadn't been given those specific directions you probably would have done the same thing anyway.) **You feel accountable for the outcome**, such as whether it works correctly or is delivered on time. And, of course, the team feels collectively accountable. (We could call this the "happy path.")

2. You would prefer to do the work one way, but you're instructed to do it a different way, either by a manager, team lead, or team consensus. You disagree with the approach, but you're not a stubborn know-it-all. You understand that their way is valid, or you don't fully understand it but you trust that someone else does. You're probably going to learn something. **You feel accountable for the outcome** in a normal, non-blaming sort of way.

3. You're instructed to do something so horribly wrong that it's guaranteed to fail badly. You're in a position to refuse or push back, and you do.

4. You're given instructions that you know are bad, you raise your objections, and then you follow them anyway. It could be a really awful technical approach, use of copy-pasted code, the wrong tools, wrong library, no unit testing, or anything similar. The negative consequences you expect could include technical failure, technical debt, or significant delays. **You do not feel accountable for the outcome.** If it doesn't work, takes too long, or the users hate it, you expect the individual(s) who gave you instructions to take full responsibility. It's not that you want to point fingers, but you will if it comes to that.

---

That fourth scenario could provoke all sorts of reactions. I'm interested in it for what you might call research purposes.

The final outcome is irrelevant. If it failed, whether someone else ultimately took responsibility or you were blamed is irrelevant. That it is the opposite of team accountability is obvious and also irrelevant.

Here is the question (finally!)

Have you experienced scenario number four, in which you develop software (big as an application, small as a class or method) in a way you believe to be so incorrect that it will have consequences, because someone required you to do so, and you complied *with the expectation that they, not you, would be accountable for the outcome?*

Emphasis is not on the outcome or who was held accountable, but on whether you *felt* accountable when you developed the software.

If you just want to answer yes or no, or "yes, several times," that's great. If you'd like to describe the scenario with any amount of detail, that's great too. If it's something you'd rather not share publicly you can contact me privately - my profile name at gmail.com.

The point is not judgment. I'll go first. My answer is yes, I have experienced scenario #4. For example, I've been told to copy/paste/edit code which I know will be incomprehensible, unmaintainable, buggy, and give future developers nightmares. I've had to build features I know users will hate. Sometimes I've been wrong. I usually raised objections or shared concerns with the team. Sometimes the environment made that impractical. If the problems persisted I looked for other work. But the point is that sometimes I did what I was told, and I felt that if it went horribly wrong I could say, "Yes, I understand, but this was not my decision." *I did not feel accountable.*.

I plan on writing more about this, but I'd like to start by gathering some perspective and understanding beyond just my own experience.

Thanks

Let me rant! I don’t usually do this but this is just frustrating and draining. Please tell me if im wrong. We have authentication that needs to be refactored. I was assigned on this issue. Im a junior btw. I also attached an image of my proposals. The issue of the old way of our signup process is that when validation fails they will keep on accepting the TaC (terms and conditions) and on our create method we have the validation and creating the user. Basically if User.create(user_params) create else throw invalid end. (Imma take a photo later and show it you)which needs to be refactored. So I created a proposal 1. On my first proposal I could create a middleware to check if the body is correct or valid if its valid show the TaCs and if they accept thats the moment the user is created. There is also additional delete user because DoE told me that we dont need middlewares we have before and after hooks! (I wanted to puke here clearly he doesn’t understand the request and response cycle and separation of concerns) anyway, so if middleware is not accepted then i have to delete the user if they dont accept the TaCs. Proposal 2. If they dont want me to touch the create method i could just show the TaCs and if they dont accept then redirect if they do then show form and do the sign process.

This whats weird (weird because he has a lot of experience and has master or phd) he proposes to create a method called validate (this method is in the same controller as the create, i think hes thinking about hooks) call it first and if it fails then response with error and dont save user, heres the a weird part again he wants me to manually check on each entity. Like User.find_by_email(bs@g.com) something like that and on my mind wtf. Isnt it the same as User.create(user_params) because this will return false if paras are invalid?? (I might be wrong here)

This is not the first time though He proposes solutions that are complex, inefficient, unmaintainable. And i think he doesnt understand ruby on rails or webdev in particular. This the first time i complained or I never complained because im thinking im just a junior and he hs more experience and has a higher degree. This is mot the case here though. I guess not all person who has a higher degree are right. To all self thought and bachelors im telling you not all people who went to prestige university and has a higher degree are correct and right all the time. Anyway ill continue later and do what he says. Let me know if im wrong please. Thanks

1) Had to fix severe bugs in a dynamic UI (configuration-driven forms) component.

Recognized undocumented Copy/Paste/Modify/FuckUp driven variations of the same component all over the project. Unsurprisingly, the implementations covered 99% of the antipattern catalog on wiki.c2.com and could compete with brainfuck in regard to human-readable code.

Escalated the issue, proposed a redesign using a new approach, got it approved.

Designed, Implemented, tested and verified the new shared and generic component. Integrated into the main product in the experimental branch. Presented to tech lead/management. Everyone was happy and my solution opened even more possibilities.

Now the WTF moment: the product with the updated dynamic UI solution never has been completely tested by a QA engineer despite my multiple requests and reminders.

It never got merged into baseline.
New initiatives to fix the dynamic UI issues have been made by other developers. Basically looking up my implementation. Removing parts they do not understand and wondering why the data validation does not work. And of course taking the credit.

2) back in 2013, boss wanted me to optimize batch processing performance in the product I developed. Profiling proved that the bottleneck ist not my code, but the "core" I had to use and which I must never ever touch. Reported back to him. He said he does not care and the processing has to get faster. And I must not touch the "core".

(FYI: the "core" was auto-generated from VB6 to VB.Net. Stored in SourceSafe. Unmaintainable, distributed about a bunch of 5000+ LoC files, eye-cancer inducing singlethreaded something, which had naive raw database queries causing the low performance.)

"I need help"

I joined this new service based company and they dumped this giant messed up jquery/php spaghetti project on me, with no comments or any technical documentation. It's completely unmaintainable.

It's been a couple days, and it has already started to take a toll on my health. I feel anxious, causing me nausea at times. I wanna quit, but no other developer is free to takeover in their company.

Am I a crying little bitch? I wanna man up to it, but it's shaking my peace of mind.

It's pile of garbage, and they want me continue working on it.

I know some of you would say, it's an opportunity to fix something. But they don't want changes or fixes. They want me to continue piling it up with more features, ultimately increasing the technical debt.

when i look at the code structure of the project i work on with my friends, i always think about how to implement the SOLID principles of bob martin for clean code
... and then i think about the clusterfuck of almost unmaintainable code that has been created over time and all the unit testing that doesn't exist at all and how much time and effort it would need to correct that code and how i realize that i don't even understand the principles and how to implement them
... and then i give up and go on coding even more mess
... and then i repeat😅😖😩

OCD driven development
- level of recursion determined by how much the algorithm bothers you
- too much and nothing is ever finished
- not enough and code is shitty and unmaintainable
- can result is longer variable names
- takes longer to name a variable
- text slightly misaligned requires hours of debugging time
- balanced by "OMFG that will take forever to fix" Sometimes...
- can lead to unobjective code reviews

In most businesses, self-proclaimed full-stack teams are usually more back-end leaning as historically the need to use JS more extensively has imposed itself on back-end-only teams (that used to handle some basic HTML/CSS/JS/bootstrap on the side). This is something I witnessed over the years in 4 projects.

Back-end developers looking for a good JS framework will inevitably land on the triad of Vue, React and Angular, elegant solutions for SPA's. These frameworks are way more permissive than traditional back-end MVC frameworks (Dotnet core, Symfony, Spring boot), meaning it is easy to get something that looks like it's working even when it is not "right" (=idiomatic, unit-testable, maintainable).

They then use components as if they were simple HTML elements injecting the initial state via attributes (props), skip event handling and immediately add state store libraries (Vuex, Redux). They aren't aware that updating a single prop in an object with 1000 keys passed as prop will be nefarious for rendering performance. They also read something about SSR and immediately add Next.js or Nuxt.js, a custom Node express.js proxy and npm install a ton of "ecosystem" modules like webpack loaders that will become abandonware in a year.

After 6 months you get: 3 basic forms with a few fields, regressions, 2MB of JS, missing basic a11y, unmaintainable translation files & business logic scattered across components, an "outdated" stack that logs 20 deprecation notices on npm install, a component library that is hard to unit-test, validate and update, completely vendor-& version locked in and hundreds of thousands of wasted dollars.

I empathize with the back-end devs: JS frameworks should not brand themselves as "simple" or "one-size-fits-all" solutions. They should not treat their audience as if it were fully aware and able to use concepts of composition, immutability, and custom "hooks" paired with the quirks of JS, and especially WHEN they are a good fit.

Can't you understand this code is unmaintainable and doing a quick fix and also requiring of me to write unit test for it IS NOT POSSIBLE without a rewrite?! FML

Facing some down - simultaneously somehow as dev and privately.

The dev part partly triggered by another burning project. Our team deep in shit up to the chin... And this unanswerable question: who is to blame? Everyone is working up their arses, but the result is still some sparkling firework ship wreck, that only held together for the demo to the board. It's not that we are stupid or lazy, yet we push some unmaintainable spaghetti, because this shit just gotta work.

Dunno, somehow this object orientation / pattern ideologies were also kind of depressing to me: partly because they smell like attempt to enlighten the inept by stupid receipts - and of course then deep down there's this nagging question if I'm not one of this inept not knowing the newest fashion template from the catalogue..

Then this Clean Code - Craftsmanship shit is bugging me similarly. Liked Robert C. Martin's book, but now I picked up some "Clean C++" and.. I kinda feel dumbed down if they try to sell the KISS principle to a 36 year-old physicist/engineer. Good for them that all our legacy shit und own fuck ups nourish this whole industry of well-meaning advisers. Argh, just fuck it, you priests, sell your obvious calendar mottos elsewhere, they are are just as useful as telling a griever that "rain follows sunshine". - As if they would not some time use the raw pointer that their coworker gave 'em, to ship shit tomorrow?

I can't stand typescript lovers

it's just typing on top of javascript... it's good but that's all - one more tool to help you build solutions

why you keep talking everyday about types, why you keep creating types for everything in the most unusuble and unmaintainable ways??

Forced to write UT on excel shiit for confirming test cases are covering units properly, but the reviewer even don't want to read test code!! it makes incredibly unmaintainable documents

You know you completely fucked up as a company, when your self-developed CMS is one huge unmaintainable hack and without any structure at fucking all.
It's just mindboggling how even such a complete mess can "attract" customers.
EXTREME STONKS 📈📈📈📈

(thankfully I am not related to that particular company which shall remain unnamed)