#+TITLE Joseph Ferano

* Thoughts on autocomplete                                             :blog:
I have a somewhat similar story. After watching Tsoding code without
autocomplete, without linting, nothing, and I decided to give it a shot and went
the minimalist route. I think my productivity has improved, simply because the
whole coding experience flows more naturally. I just code what's on my mind and
I only get interrupted by my tools when I actually ask for help, ie compile And
now I think those things are overrated. I also think there's such a thing as
programming languages and tools that require LSP more than others. I have a fear
that LLM AIs are going to make this worse The underlying principle is that, as
the programming ecosystem develops more and more sophisticated tools that remove
the friction in programming, by reducing how much code you have to write or by
glossing over hairy technical details, you stop thinking deeply about problems,
but this new programming velocity means you can produce code much faster, and
even author codebases that are much more advanced than you properly understand
So what this does, in turn, is that it makes abstractions and complexity easier
to manage for individuals because anything they don't get they can just get AI
to solve it for them. So there's less pressure to design things in as simple a
manner as possible. There's less pressure to keep a feature set small enough
where it can fit in someone's head.

My fear then is, as AI progresses, software bloat is only going to get worse.
You have a counter culture emerging now with groups like Handmade Network, but
for the most part, developers are ok with more and more complexity, so long as
it makes their lives easier. So someone like myself is fucked, because I refuse
to go down that road. I want to understand what's going on with the code that I
write. Emacs and Vim will have to keep adding shit to their codebases in order
to keep up with all the crap people keep coming up with, if not, Visual Studio
Code will just keep merrily bloating itself and then eventually, if I want to do
some kind of program, I'll be stuck in a position where I HAVE to use VSCode, if
I want to make sense of all the shit going on

The main example that comes to mind is Java and C#. When you use these
programming languages, you ask yourself why are they so complicated compared to
others. I used to write C# in Vim and then I wrote C# in Jetbrains Rider, when
it came out. The difference between the two was considerable. But then I used
other languages, like F#, and I noticed that I didn't see a marked improvement
between vim and Rider. Then it got me thinking that likely a lot of design
decisions for these languages were acceptable because of the crutch of the IDE.
The tools reduced the complexity of a complicated language, to the point where
using the tools without the IDE was painful.

I think Rust and javascript frameworks have a similar thing going, where they
are being enabled by the tooling ecosystem that surrounds them, which lessens
the cognitive load, which in turn increases the cognitive burden budget
designers have I think that's what I would base this on;

Reducing the cognitive load to read and write a codebases written in a language
or framework increases the cognitive burden budget designers of these
languages/frameworks have My argument is that AI might become the new IDE, and
it might affect even more things, further increasing the cognitive burden budget
this current generation of junior programmers will work with once they become
skilled enough to start working on the languages and frameworks the future
junior generations will use

Now, let me clear up, I don't think this is a conscious decision on the part of
software developers. I think that they produce things they think would be
helpful, then they see what adoption looks like. By reducing the cognitive load,
the ecosystem can more easily consume complicated software, thereby triggering a
positive feedback loop of adding complexity and acceptance because of the crutch

Milhalis:
    I think it’s mostly about being able to quickly understand the context
    With LSP you can get down to base type of anything very quickly
    And generally navigate code in better way then top to bottom, to find content about specific part and relevant functions/data 
    I guess the difference is how complex the base type can be
    With something like C just grep’ing the function is enough
    With C++ you already need much more context but it’s still manageable
    With C# the spider web of related things to that type can be all over the place
