Oh, it’s only the files that have over 2k lines of code? Hell, I’ll take that over what I’m dealing with now. I’ve got multiple FUNCTIONS that are over 2k lines. >:(
Yeah, I dont see a big problem with files over 2000 lines in some cases, as long as things remain well writrej, organized, abstractd.
One piece of garbage that I’ll never touch again hae most functions this size. One was 50,000 lines! Hundreds.of lines of if/else, half of the functions passed the same 60 arguments because he didn’t understand classes or even dictionaries, etc etc. And was used heavily.
well writrej
oh dear
Lol I’m leaving it
Yeah, honestly overly splitting things up is worse sometimes, that’s how you end up in Java land. Any time you want to grok a specific function you end up down 30 abstracted code paths. Essentially need a compiler to unroll it all to actually see what it’s doing.
Java was exactly the negative use case I was thinking of. Trying to track down the flow of things for code I don’t look at regularly drives me insane.
There are no comments in the code
At my last job, I was assigned to a project being run by a straight-out-of-college developer who felt that not only were comments unnecessary, they were actually a “code smell”, a sign of professional incompetence on the part of whoever added them. It’s an insane philosophy that could only appeal to people who have never had to take over an old codebase.
I kind of get the idea that code should be self-documenting, but at the same time, there’s so many crazy business rules that comments are basically a necessity if nothing else other than to explain why in the hell the crazed mess that provides the required functionality for the business rules exists.
Yeah some comments are not useful
# returns the value as a string return str(user.id)Some comments are
# returns the user id as a string because ZenDesk's API throws errors if it gets a number. # See ticket RA-1037 # See ZenDesk docs: https://etc/ return str(user.id)That’s typically what people who advocate for less/no comments really mean. The code should self explain “what” it does, but if the “why” isn’t obvious (i.e. confusing business logic) nobody argues that you shouldn’t comment it. That’s how I’ve worked in every company I’ve been at (and all developers around me) from 50 person start ups to >2k people. It’s really common mentality with Ruby developers
Anyone complaining about commenting should be forced to code in assembly for a while.
deleted by creator
Or, it appeals to people that have had had to take over an old codebase where the comments were all lies.
“Code never lies. Comments sometimes do.”
It’s funny, the exact same logic applies to method and variable names. There’s no compiler that ensures that a method’s name accurately describes what the method does or ensures that a variable’s name accurately describes what the variable represents. Yet nobody ever says “you shouldn’t use descriptive method and variable names because they might be misleading”. And this is hardly academic: I can’t count the number of times I’ve run into methods that no longer do what the method name implies they do.
And yet method and variable names are exactly what people mean when they talk about “self-documenting” code.
That’s fair!
I don’t know that I could have stopped myself from asking whose nephew they are and I’m just a hobbyist
That’s what agentic AI is for! Your OS will figure out by itself what you are doing and weave together a shambolic rococo digital house of cards that will be not just undocumented but utterly incomprehensible.
It’s fine, just get a 5GHz CPU with 48 cores, 1TB of DDR5 HBM super RAM, and maybe a few petabytes of storage (in the cloud in a flatpack Docker that runs on a VM), so that you can finally make that button blue.
Shut up and take my venture capital money! And maybe 2/3 of the whole market cap in stock options! /s
Fucken right, get your agentic AI to get in touch with my agentic AI (with wire transfer deets)
Bonus frame:
The 2000 line file is one function
That implements a ******* VM in which all of the byte code runs in, and rest of source is just byte code listings that the linker magically gathers into a working program.
What’s a hunter2 VM?
Oh, so you worked with my ex-coworker.
It implemented a database. Giant branching if/for loop.
I’ve been doing this for years at my current job. It has become a masterpiece of refactoring and comments. They weren’t even asking the right questions. I’m very proud of myself.
So naturally, I’m about to get fired and have the whole thing redone by AI.
Then re-hired for 3x salary to make it work again, I hope. Or just watch the company/project fail spectacularly
I didn’t even know we were hiring …
every programmer I’ve seen who says their code is self documenting writes dogshit code
I think we’re all just dogshit but think we’re better than the next person, it’s like driving. I’m a “comment if there’s no way to make it readable” kinda guy, I work with some “comment and don’t bother to make it readable because there’s comments” people. We all suck. I probably forget to comment on unreadable places sometimes, or overestimate readability he either doesn’t update comments so they’re out of date or the code is so gibberish that a comment didn’t help.
Ideally I guess you comment AND make it readable AND make sure the comments are up to date, but who do you think we are? Superman? And what’s the right level of commenting anyway? Probably depends on who is reading them.
Those are rookie numbers. We got functions with 5000+ lines and 20 levels of indentation directly in the user-interaction event handlers :)
Well, that’s how you do it!
And if two widgets need to create the same effect, you just copy the 5000 lines around. That’s why copy-and-paste was invented.
(It really shouldn’t be necessary… but in case somebody still needs it, here’s the \s)
This is the right strategy. Storage space costs nothing these days. Why not just clone and go? That’s what I always say.
Why, you can just ‘inherit’ some code by copying a block, pasting it, then making a few small changes. No thinking, no problem.
Ok, I’m off to copy of my code folder for the next release.
The link is a proxied image link for some reason.
This is the dram. Since the entire codebase is shit, you basically have to rewrite it basically in its entirety.
Which means you can do it with an actual good design.
And if you mess up on something, you have a working version you can consult.
- N-deep loops mixed with gotos, throws, multiple returns, and mixed memory management contracts.
#include “globals.h”
// please help
With the short variable you probably also get shadowing. That’s super fun in a new code base.
Or another favourite of mine: The first time I had to edit a perl script at work someone had used a scalar and a hash with the same name. Took me a while to realize that scalars, arrays, and hashes have separate namespaces, and the two things with seemingly the same name were unrelated.
I can live without documentation and comments, but then you’ve got to write really well-structured, self-documenting code. Which means long variable names (or better: local constants) that describe exactly what’s in them, and function names that describe clearly what the function is for, and readable code that shows what it does.
But perhaps expecting that kind of discipline from people who lack the discipline to write documentation, was not entirely realistic.
Allow me to introduce a shit ton of jQuery into all the jsp files you got.
A few years ago I had to port a tool from HTBasic (a proprietary BASIC dialect) to Python. The original source only runs in their proprietary IDE. Of course, no comments whatsoever and a lot of GOTO magic and matrice calculations some of which have no other purpose as to confuse the reader. The variables had only cryptic and meaningless three digit letters. My theory is that they intentionally wrote it in a way that it would be a nightmare to reverse engineer. And they succeeded.
