Does Visual Studio rot the mind? (2005)

This feels very similar to me as the "Tutorial Hell" effect. Where I can watch videos/read books, and fully feel like I understand everything. However, when hand touches keyboard I realize I didn't really retain any of it. I think that's something that makes AI code gen so dangerous. Even if you think you understand and can troubleshoot the output. Is your perception accurate?

I was programming 40 years ago and was very happy to be able to use "high-level languages" and not write everything in assembly. The high-level languages enabled expressiveness that was hard with lower levels.

This is a tangent, but perhaps relevant:

I think sending your LLM all relevant data structures (structs, enums, function signatures etc) is mandatory for any code-related queries. It will avoid problems like this; it seems required in many cases to get integratable results.

If you're active on social media (twitter), you will still see people, like the FFmpeg account, still bashing higher level languages (C) and praising hand written assembly.

Embedded programming is still like this. Most people just don't inspect the assembly produced by their compiler. Unless you're working on an extremely mainstream chip with a bleeding edge compiler, your assembly is going to be absolutely full of complete nonsense.

For instance, if you aren't aware, AVR and most other uCs have special registers and instructions for pointers. Say you put a pointer to an array in Z. You can load the value at Z and increment or decrement the pointer as a single instruction in a single cycle.

GCC triples the cost of this operation with some extremely naive implementations.

Instead of doing 'LD Z+' GCC gives you ``` inc Z ld Z dec Z ```

Among other similar annoyances. You can carefully massage the C++ code to get better assembly, but that can take many hours of crazy-making debugging. Sometimes it's best to just write the damn assembly by hand.

In this same project, I had to implement Morton ordering on a 3D bit field (don't ask). The C implementation was well over 200 instructions but by utilizing CPU features GCC doesn't know about, my optimized assembly is under 30 instructions.

Modern sky-high abstracted languages are the source of brain rot, not compilers or IDEs in general. Most programmers are completely and utterly detached from the system they're programming. I can't see how one could ever make any meaningful progress or optimization without any understanding of what the CPU actually does.

And this is why I like embedded. It's very firmly grounded in physical reality. My code is only slightly abstracted away from the machine itself. If I can understand the code, I understand the machine.

If your job for 30 years is to move bags of cement 50 miles each day, is it not more productive to use a truck than your legs? Even if you use the truck so much you could not move a bag of cement with your legs anymore due to atrophy?

You could make the same argument about most tools. Do calculators rot the brain?

How different is this argument from "does Rust rot the mind"? After all, Rust means that the part of the brain that is paranoid about careful memory safety issues no longer has to be engaged.

Like most things, the answer is that it depends. I think autocomplete is great, and I've come to appreciate LLMs doing boilerplate editing, but I'm quite worried about people using LLMs to do everything and pumping out garbage.

Great point, to me it feels more like running barefoot versus with padded shoes. Barefoot running will build your foot muscle based on your natural form over time, whereas padded shoes may interfere with your natural form and at worst encourage bad form which may lead to injuries as your mileage increases.

Over the years in building software, I tend to spend more time thinking about how all the pieces (i.e. from package manager) fit together rather than building them from scratch and fitting two pieces together require deeper understanding of both the pieces and how the combination of the two behaves in the environment.

Completely agree. Though I think this statement could benefit from pointing out that cars also help people go much faster, and do things they otherwise couldn't.

But also gives us back time and mental capacity to do other things which were previously out of reach because of what we had to focus our minds and time on.

In some cases, maybe even many or the majority of cases, that trade isn't a bad one. It really depends on how you use it.

Socrates just argued about semantics. If you take anything away from those dialogues it should be that they were confused and didn't really have many good ideas.

Being an active transit crank, I'd like to put out that if computers are a "bicycle for the mind", LLMs are an SUV.

My background is heavily biased towards C++ but I don't really feel like you can make it work in VS Code without understanding, at minimum, where your clangd is actually located. The C++ plugins don't install what you need where you need them, and the launch.json really does not just work. My ex was unable to set up a C++26 toolchain for VS Code because without my help he couldn't configure the settings to connect to the right version of clang tools, and I don't think he ever got the GDB debug adapter working at all.

my version of this was "do convenient linux distros and binary package managers rot the mind?" after setting up a freebsd box with everything built from source and everything configured by hand. then again from building an arch-based Linux system from the wiki. you learn a lot from doing things by hand... but eventually you need to get stuff done.

The number of times I've had to help a colleague troubleshoot some VSCode thing seems to bear this out. I'm regarded as a 'wizard' because I actually know how to use git/build tools without a gui. It's kind of shocking to me how many developers' knowledge ends at the run button.

It doesn't bother me too much, because I like being needed, lol. But it would probably make our team more productive if people bothered to learn how our tooling works.

Vibe... coding... I'm getting old, what is this?

Still rough around the edges on mobile. Too much margin on the right, and code blocks appear tiny.

I feel like with tools like cursor, while you may be able to cobble together a todo app or something else simple without any programming knowledge, for anything bigger you will still need to know how the underlying thing works.

With everyone now using LLM's, the question goes form "who can code the best" to "who can prompt the best" but that still comes down to who knows more about the underlying code.