|
I agree.
In my experience, more senior people these days are missing the point, and fail to grasp that the demon we're fighting is called complexity.
It's a worrying trend, because I don't like cleaning up after seniors. They get annoyed and snarky.
On the other hand, the work environment keeps improving year after year.
I'm in a mature fintech company now, and apart from the occasional mansplaining, people have stopped assuming I know nothing just because I'm a woman, which is nice.
|
|
|
|
|
Non-intuitive interfaces.
No ability to handle general solutions (if the dev didn't know about it, it doesn't exist).
Concentration of efforts on form rather than substance.
Written, ever more often, by those lacking a real attention span, except for grasping their cell phones in one of their paws.
Driven by business models that want a product, even if they know it's defective.
And did I mention "Agile" ?
Debugging via the clients (gotta meet those deadlines!)
Ravings en masse^ |
---|
"The difference between genius and stupidity is that genius has its limits." - Albert Einstein | "If you are searching for perfection in others, then you seek disappointment. If you seek perfection in yourself, then you will find failure." - Balboos HaGadol Mar 2010 |
|
|
|
|
|
You hit the nail on the head when u mentioned Agile. It is a way to get crap out the door faster. 2 or 3 sprints after "enhancements" were completed, 50% of those "enhancements" had bugs. Nuff said.
|
|
|
|
|
Start of a new project:
"We do SCRUM here, so Agile basically, which means we tell you want we want every other week.
For you that means you just build what we've asked you, and you don't have to worry about details or documentation.
Just make it work. Let us worry about the details."
3 months later:
"What does this button do? I don't remember asking anything like that. That doesn't sound like anything I would ask.
I mean, if you think about it, it doesn't even make sense to have a button like that. Just remove it."
6 months later:
"Well, I don't get it. I mean, I get the idea, obviously, but I don't understand how it's all supposed to come together in a way that makes sense to the client.
Let's redesign the interface, this time, I'll micro-manage all the design decisions."
9 months later:
"At a trial run at a potential customer, we got the remark that our core functionality was somehow missing. How is that even possible?
I clearly remember seeing it at some point in the past. Where did it go? Who is cutting features without consulting me?"
Based on a true story.
|
|
|
|
|
First:
The change I see is not so much on overall code quality (it's always the same: experienced seniors write stable code "as they did for so much time" and juniors with little to no experience "write code where the cursor just happens to be").
So many (young and old!) devs totally under-estimate that correct formatting, naming and intending is super important.
I call that "polite code". Code that can be read by someone else.
Not that mess of a mixture between blanks-or-tabs, sometimes 4-indent, sometimes 2...
Second:
The real problem these days arise when a web-dev meets a desktop-dev, or a so-called "script dev" meets an "oop dev" (don't you dare to tell me, php is an OO-language! it knows classes, but that doesn't make it an OO-language).
There are really GREAT frameworks and design toolkits and a thousand great libraries out there that allow you to create cool websites in minutes.
Same is true (to some extend) for mobile devs and a bit less for desktop devs.
One can like or dislike platform-independent languages which produce output for all of them, that's not the point.
The Point:
The point is, while some (experienced and newbs alike) see coding these days more like building a Lego-House by just putting some pre-made pieces together and hoping, it will all work out, some others don't like all that high-level stuff and prefer to code as-low-level-as-possible, doing everything by hand.
While its true, the latter will have more control over things that happen, the others are super-fast. Managers often see only "time and costs" and will go for the high-level path.
The Result:
8 out of 10 websites look the same, have the same bugs, because they are done with the same toolkit by the same kind of people, who no longer care about "the stuff behind the scenes".
But they were fast and therefore cheap.
So, yes, the overall quality is going down. Lightning-fast. But it looks amazingly good while it does that.
Just my 2 cent
|
|
|
|
|
... the experienced developers are generally producing better code, mostly because the tools (IDE, languages, frameworks) allow them to concentrate on the task instead of the lower level mechanics.
But ... the inexperienced are producing worse code, mostly because the tools (IDE, languages, frameworks) allow them to concentrate on the task instead of the lower level mechanics! And if you don't know how to do it, copy'n'paste random code from SO and wonder why your C++ compiler doesn't like PHP ...
"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!
|
|
|
|
|
From newbs, young experts, old farts... I still see
* code not indented
* code not commented
** stupid comments that describe the line of code and not its significance
* unneeded global variables
* unchecked return values
* other language-specific blunders
Nothing changed, except that there are many more "toy block tools" that further confuse things,
GCS d--(d+) s-/++ a C++++ U+++ P- L+@ E-- W++ N+ o+ K- w+++ O? M-- V? PS+ PE- Y+ PGP t+ 5? X R+++ tv-- b+(+++) DI+++ D++ G e++ h--- r+++ y+++* Weapons extension: ma- k++ F+2 X
|
|
|
|
|
You're working too much!
If those globals aren't needed, delete them and see what happens!
|
|
|
|
|
When I can refactor the code, sometimes I do exactly this. You'd be surprised (probably not) on how many global symbols are declared and never used, or used once in a function (because static variables are forbidden knowledge).
GCS d--(d+) s-/++ a C++++ U+++ P- L+@ E-- W++ N+ o+ K- w+++ O? M-- V? PS+ PE- Y+ PGP t+ 5? X R+++ tv-- b+(+++) DI+++ D++ G e++ h--- r+++ y+++* Weapons extension: ma- k++ F+2 X
|
|
|
|
|
I'd been writing C++ for years before using and then appreciating static variables in functions.
|
|
|
|
|
I usually avoid them unless I'm writing firmware (often stack size is measured in bytes so statics are used instead of local variables) because in my experience module variables are usually the best solution when statics are needed - they are more easily observable and they can be modified by other functions/methods.
GCS d--(d+) s-/++ a C++++ U+++ P- L+@ E-- W++ N+ o+ K- w+++ O? M-- V? PS+ PE- Y+ PGP t+ 5? X R+++ tv-- b+(+++) DI+++ D++ G e++ h--- r+++ y+++* Weapons extension: ma- k++ F+2 X
|
|
|
|
|
It even took me longer to realize that module variables are often a good replacement for static class data! I've got a pile of them to move, but my C++ tool now flags them and I'm working toward it being able to do the edits automatically.
|
|
|
|
|
Add to your list:
* Poorly organized code.
* Executable code in C/C++ header files.
* Vague structure names like xx_
* One of my !favorites "if ( 1 == A ) "
* Unclear/non-descriptive function names
* One line functions e.g., AplusB (int a, int b { return a + b; }
|
|
|
|
|