Things is you don’t crunch numbers in Python code, you do that in libraries called from Python.

It’s a few statements of orchestration and any heavy lifting is encapsulated compiled code.

You don’t do tight loops on Python, or if you do you’re using it wrong.

Master’s degrees though — racist as fuck.

Golang is technical debt in language form. A language that gained limited and now sagging popularity, for good reason. I hate to work in Java but hate golang more. It’s the lightsaber of programming languages. I’ve got shit to do, give me blasters and all the rest. And I’m not interested in wanking myself off about how I did it all with channels. [edited for typo/clarity]

Hmm, I’m not taking about hacking defaults, I’m talking about hacking functionality. I’m talking about making capabilities that didn’t exist, all seamlessly part of my typical integrated text manipulation environment (that’s way broader than editing)

The unique power of emacs is it doesn’t have typical boundaries, so integrated personal unique functionality is possible. May well be a huge downfall, security wise - it rides a lot on security through obscurity.

Frankly it’s taken me decades to properly appreciate how my computer experience can be so fungible. Most computer systems don’t allow it.

Lazy about tooling? The biggest point people make is that IDEs tend to work out of the box while the likes of vim or emacs need configuration and have an initially steep learning curve.

Well, as in this discussion, some people sometimes also tend to raise a lot of features as if only IDEs have them, but that’s frequently just ignorance.

Hackability not on your list? It’s the ability to extend and adapt it to my particular needs that, above many other things, means I am too deep into Emacs to even imagine leaving.

Plugins are a very weak substitute that cannot provide that utility, and I notice Helix doesn’t even offer plugins. That sword does have the horrendous opposite edge of almost total lack of security, so perhaps I’ll regret that one day. There are so many ways I value Emacs that isn’t matched by any other text environment that none of the others are even on my radar as possible replacements.

Out-of-the-box experience is very weak on Emacs, but I’m decades past that being a concern to me directly, though it does inhibit newcomer uptake.

Other than that, for me it ticks your boxes while barely scratching the surface of its merits. At least its speed and latency is not something I notice any meaningful benefit when working with something that people praise, like vim. Come to that most of the time like now, typing into a browser text box, I’m not even bothered by latency, and that’s way worse than Emacs.

It’s biggest failing to me is working remotely when there’s significant network latency, where VSCode is clearly superior, but I have neither the time, nor probably the ability, to fix it.

Dude, your þey business immediately turns 80% of readers against any message you may be trying to convey while the rest will be saying “Okay, they may be an insufferable dweeb, but that doesn’t mean they’re wrong, so let’s try to give it a fair read”…

I swear some of you people think some of the most talented and productive experienced devs use vim and emacs because of some snobbery or because they haven’t noticed vscode etc exist.

It really is unique.

Well j = i + 1, and drop the equality test.

I’m now 1 year in to working in Go having been mostly C++ and then mostly large-scale Python dev (with full type annotation).

Frankly, I bristle now at people giving Python a hard time, having worked with Go and I now hate Go and the de-facto ethos that surrounds it. Python may be slow, but for a lot of use cases not in any way that matters and modern computers are very fast. Many problem areas are not performance-limited, and many performance problems are algorithmic, not from raw statement execution. I even rewrote an entire system in Python and made it use 20% of the CPU the former C++ solution used, while having much more functionality.

The error returns drive me nuts. I looked around for explanations of the reasoning as I wasn’t seeing it, and only found bald assertions that exceptions get out of control and somehow error returns don’t. Meanwhile standard Go code is very awkward to read because almost every little trivial function calls becomes 4 lines of code, often to do nothing but propagate the error (and errors are just ignored if you forget…). With heavy use of context managers, my error and cancellation handling in Python was always clean, clear, and simple, with code that almost read like whiteboard pseudo-code.

The select statement can be cool in Go, but then you realize that literally 98% of the times it’s used, it’s simply boilerplate code to (verbosely) handle cancellation semantics via the context object you have to pass everywhere. Again, literally code you just don’t need in exception-based languages with good structures to manage it like Python context managers.

And every time you think “this is stupidly awkward and verbose, surely there’s a cleaner way to do this” you find people online advocating writing the same boilerplate code and passing it off as a virtue. e.g. get a value from a map and fall back to a default if it’s not there? Nope, not offering that, so everyone must write their own if foo, ok := m[k]; !ok {...} crap. Over and over and over again the answer is “just copy this chunk of code” rather than “standard libraries should provide these commonly needed utilities”. Of course we can do anything we want ourselves, it’s Turing Complete, but why would we want to perpetually reinvent these wheels?

It’s an unpopular language, becoming less popular (at least by Google trends) and for good reason. I can see it working well for a narrow set of low level activities with extreme concurrency performance needs, but it’s not the only language that could handle that, and for everything else, I think it’s the wrong choice.

Go code is always an abomination.

Dynamic typing is shit. But type annotation plus CI checkers can give you the same benefits in most cases.

Once you need performance

If you need more performance. Many things just don’t.

Excellent description of the zeitgeist.

Your portrait of before generative AI is a bit hard to square with the ad driven internet, but fits ever better the further back you go.

Yeah, we’re turning it all to shit in so many ways simultaneously, it’s truly something awful to behold. Maybe there is a singularity coming after all, but it’s not one like the credulous tech worshippers imagined.

Git’s unconventional and decentralized design—nowadays ubiquitous and seemingly obvious—was revolutionary at the time,

Of course, there’s more innovation in git than being DVC but the decentralized nature wasn’t revolutionary.

It was funny when I started using bzr and then git, I kept being told “it’s a DVC, which is a different way to work that takes some getting used to”, and I was puzzled as it felt very familiar to me. Then I looked up DVCs and found out that Sun’s Teamware that I’d used for a decade was also a DVC. It was actually a return to familiar and comfortable workflows after a brief period using abominations like Perforce and Clearcase. I’m so glad they’ve been largely replaced. Git may not be perfect, but it’s better than those in any use cases I have had.

When bzr, and then git, turned up and I started using them, I was told “this is DVC, which is a whole new model that takes getting used to”, so I was surprised it seemed normal and straightforward to me.

Then I found out that Sun’s Teamware, that I had been using for many years, was a DVC, hence it wasn’t some new model. I’d had a few intervening years on other abominable systems and it was a relief to get back to DVC.

Regarding the original post, are there really people around now who think that before git there was no version control? I’ve never worked without using version control, and I started in the 80s.

Figuratively, Street kids do tend to be.

Yes it’s trivial to host a repo, and then you have achieved approximately 2% of a forge.

If I went back to the vi interface for some reason I’d at least use ctrl-[. I dislike lifting my hand more than I dislike using modifiers.