Hacker News Reader

> That held true for search and that holds true with AI coding assistant.

100% - this was not obvious to me until I was working at a startup and delegated a task to some others. They tried for close to an hour to find a solution to a problem and came up empty handed. I had a go and instantly found the answer.

What was the difference? It was our ability to put into Google the right terms to find the answer.

Already I find myself doing most coding via AI, with my work being high level skills (choosing how to organise code, knowing when to refactor and when the AI has gone too far).

The productivity increase is crazy.

The future quite likely will look like the minority report interface.

So, this sucks btw. Some people would make much better code if they at least had a working model of how computers actually compute.

Your parent comment is literally describing the ‘push button to diagnose patient’ “doctor” machine in idiocracy, and lauding its coming.

A somber harbinger of our near future.

No worries girl! Plenty of tards livin kick ass lives! My first wife was tarded, now she works at microsfot.

I've observed another meta as well: IDEs/language servers.

I was writing a Wordpress plugin and by default in PHP all function definitions are global, e.g. is_single that WP defines is global. Naturally to avoid conflicts you would use a namespace, but since most of the examples I saw used prefixed function names, I decided to try that as well.

In my opinion, coding just feels much clearer when you prefix all your names, like my_library_my_func. When I see my_library_, I just immediately know that is my code. If you use different prefixes for different modules, you can tell from a glance which modules a piece of code interacts with. In C++, you can tell a random word is a field by the simple fact everyone prefixes them with m_. I've seen people using prefixes for pointers as well.

This is the same concept you have when designing an UI. Everyone agrees a problem with hamburger menus is that you don't know what's inside the burger until you click on it. If you want people to be aware something exists, you need to make it appear on screen, explicitly.

Instead, languages have evolved toward the very opposite. We ran away from self-documentating variable names and prefixes, and toward namespaces, "const" and other keywords, and "OOP" that feels less object-orientated and more press-the-dot-key-to-get-a-list-of-methods orientated. We depend on docstrings that show in the IDE, and then on auto-generated documentation from those docstrings. Typescript is probably the worst case of this, because it gives you a lot of tools to make the dot work the way you want, you'll spend way too much tinkering with the dot instead of just writing code that actually runs.

Thanks to this, when you look at code, you have to wait until your language server figures out what you're looking at for you. If the IDE doesn't work, it's effectively impossible to code anything in many cases. But the variable names are shorter so people think it's cleaner and better, like removing features from an UI to make it cleaner.

You've highlighted why I migrated from being a front-end dev to a backend dev, as close to the metal as possible. The upper layers are a shitshow.

LSP are useful but some languages are becoming useless - harder than they should be - without LSP, and that's going too far.

> as close to the metal as possible

Seems like a bold claim. Care to back it up?

> We ran away from self-documentating variable names and prefixes, and toward namespaces

   namespace Gujarati { class Masala { ... } }

   Gujarati::Masala m; // variable with required namespace
   using namespace Gujarati;
   Masala m2; // variable with implicit namespace
   Gujarati::Masala m3; // variable with unnecessary explicit namespace

   namespace Bengali { Gujarati::Masala the_masala; }
   
   Bengali::the_masala = ....;
   using namespace Bengali;
   the_masala = ....;
   Bengali::the_masala = ...;

AKA "do watcha wanna do"

Especially since most Bengalis would say moshla...

You just reinvented Hungarian notation (the bad version).

A language where every definition is global is the worst starting point imaginable. Of course, solutions to that will remain severely lacking. Prefixed variables as you propose were abandoned for good reason.

Perhaps give Rust or Python, maybe Go a spin, and see how they do namespaces, imports and such. I find that mostly sane and readable, as they retain the full chain of custody (you can always trace where a symbol comes from by its qualification or import statement, unlike in less sane ecosystems such as C/C++/C#/Java, and apparently the insane version PHP uses).

You must have not used C# (or even Java in better conditions) in recent years to legitimately suggest picking Go or, worse, Python over them.

Modern C# is a lovely language overall but I think OP talked about the module system where the more explicit approach of Python is arguably better.

When dealing with C#, if you’re browsing code un anything less than a IDE it can be really hard to find where a symbol comes from. And that is if the author was nice enough to use one folder per namespace, otherwise it becomes a nightmare.

In case of external references, most of the time, you do not need to browse the source files - that's something you reach for if inline documentation and type system are insufficient. Arguably much more of an issue in dynamically typed languages, yes.

Although even source browsing is now easy - you just press F12, and packages come with sourcelink integrated automatically (previously you had to rely on IDE to resolve symbols or decompile it from IL (readable but not perfect, Rider did and still does it really well)).

Navigating the solution itself does not differ significantly from Rust and its crate system. People usually structure the code by projects and folders, sometimes aggregating multiple types in a file (because you don't need a separate file per a couple of 4 line class declarations) sometimes not but I generally find the structure way more browsable than e.g. what a typical TypeScript project looks like. The regular symbol navigation rules apply - F12, Shift+F12 and friends.

Exactly.

In Rust, Python and Go you can trace every symbol back to its source by just reading source code. `cat file` would suffice.

In C#, that’s impossible by design, as you say. C# imports work like wildcard imports in Rust and Python, which are wildly frowned upon for very good reason (except for specific cases like preludes in Rust).

I’m impressed by your teacher’s foresight. That’s _exactly_ how I see it. I don’t memorize things, I just know _how_ to find them when I need them. You can store a much larger “index” in your head than raw knowledge, which is what I strive for.

The problem is that going from assembly to advanced compilers still produced the same output every time with variations based on you selecting them from a limited pool of options.

With LLMs, statistics play a much more important role so you're really not in the same realm anymore. It's like going from digital to analog, things work differently at a core level.

I still believe that warhammer 40K is the most accurate depiction of advanced tech. We will all just become tech priests praying to the machine spirit to get the computer to do what we want.