I know at least some of my slowness is crowdstrike, especially since I can A/B test non-Emacs operations with some coworkers with older machines that don't have the bad config.

There are just so many little operations that cause stuttering on macOS with an unfortunately over-eager crowdstrike configuration. Magit is the worst offender but it causes paper cuts all over :(

Corporate EDR BS.

I thought Emacs was terrible to use until I realized it was extremely fast on my home computer. All the pauses that EDR does combined with Emacs mostly single threadedness is a bummer. I still daily drive it now for my IDE at work because it's workflows work better for me than others, but it is such a bummer.

Typescript is a perfect example of why Emacs shouldn't own that setup. Typescript version 6 uses the "typescript-language-server" which is a totally stand alone nom package for lsp support.

Typescript 7, is incompatible with typescript-language-server and the compiler itself now acts as a lsp.

If Emacs handles that all by default it then needs to handle versioning of each language server itself across all operating systems, handle cases when different machines have different npm version managers, upgrades, etc...

It's not impossible but it's a lot to ask, and it requires more frequent version upgrades just to keep things in sync.

I couldn't even use the built in version of eglot and had to use ELPA version for bug fixes that affect c# LSP support that were committed to the package back in December.

I decided to de-IDE myself and as part of it I decided to look at my options. The more I saw of Emacs the more interested I got. However using the Doom emacs distribution kind of threw me in the deep end without actually understanding how Emacs operates. I was lost and bounced off quick.

I decided to take the approach of starting with vanilla Emacs and trying to get it to work for me as an IDE one step at a time. This post was me documenting that and actually trying to understand each component or feature I was trying to utilize.

I figured I would post it here in case someone else is interested and wants to try and break through the Emacs wall.

Comments URL: https://news.ycombinator.com/item?id=49420055

Points: 15

# Comments: 2

It's not trivial though and it's a good thing I am willing to tinker and explore. I got a decent Neovim development setup going in a few days with the help of blog posts but Emacs is a whole different story, with a lot of legacy terminology and a lot of very sporadic resources. Doom suffered (for me) from a lot of complexity, assumed emacs knowledge, and confusion for how to customize. Emacs Kickstart was closer to a jumping off point but still had a lot of confusing things going for it.

I'm still making the leap because I see the potential to have a truly customizable IDE that's customized to me (and not throwing AI things at me every few weeks) but sheesh, it's not trivial.

Getting a free hobby license requires emailing them with MAC addresses (which means I have to do that for my desktop, laptop, and again for any future machine I may get). Then getting the tools to actually run on Linux seemed to be impossible that I just gave up.

It's not clear that I have the Yosys and open source options for my Xilinx based fpgas.

So there's a lot of nuance to the "is it that you enjoy figuring out the instructions to use to solve a problem".

At the surface I don't enjoy typing, I don't enjoy fighting syntax checkers, rust's borrow checker, or manual memory management in my personal C projects, typing out the HDL for nand2tetris problems, etc...

However, there have been studies done decades before this LLM boom about the psychological concept called the Generation Effect. While everyone is different and it's not completely black and white, the studies have found that people learn more by actual practice (the act of doing) than just by reading material. That's 100% the case for me.

I can read blogs and resources till the cows come home and I'll have a very surface understanding of a concept. Then I'll go to write the code to implement it and it rarely works right away because there are demonstrable gaps in my understanding. I'll debug it and iterate on it until it works, and that is what actually solidifies the mental model of what I was trying to learn in my mind. Not only can I say for sure that I remember it better, that seems to form connections in my brain that allows me to apply it in other use cases, or build fascinating technical tangents.

I not only get my high from that initial "Aha!" moment when I really feel like I understand a concept enough to actually apply it in other scenarios, but I also get my high from tangents that spawn off of that concept.

In many cases, I can map a direct line of my personal projects to a set of root projects that spawned them off because of ideas I came up with while actually implementing the projects. Since I tried real hard to optimize a C# game engine for an embedded platform, I realized where limitations were and it solidified my knowledge of how old game consoles worked.

This led me down to the interest of creating a GPU out of embedded device that I can pair with I/O constrained embedded devices. This taught me soooo much about the embedded space, and while I heavily improved my C writing abilities it also made me wish I could write C# on embedded.

Since I had learned C for the embedded project (and I knew MSIL from previous deep dives), I realized I can just translate MSIL into C and that would allow me to run C# anywhere (got C# working on an SNES, the linux kernel, and on an ESP32S3).

By implementing that by hand and coming face to face with many small decisions I had to make, that solidified a bunch of concepts in my head around intermediate representations and why they are a massive benefit. Those aha moments (among others) then led me down the path to implementing a just-in-time compilation engine for NES games and the C64 OS into the .net runtime.

The learnings from that have already spawned some other ideas in my mind, which is why I'm now learning Verilog and FPGA development.

None of these projects solved any useful problem (as in nothing was created that I or anyone else would use). The satisfaction and the high I got from them was having the curiosities of a problem, ideas of a solution, and persevering (partially due to being stubborn) through it and actually accomplishing it. The satisfaction that I actually understand the concepts at a foundational level, which actually ends up breeding excitement for a whole other tangent/problem.

These learnings have indirectly helped me in my day job as well. While I'm not working on anything that sophisticated or cool, all of these actual implementations I've learned have given me direct learnings I have been able to successfully use to create better software in other domains.

So it's not the actual typing I enjoy, but the whole picture of what comes out of the end through that typing. LLMs take most of that away. It lets me ideate on a vague solution and then it goes ahead and implements it for me. Even if I'm specific on the details of the algorithm it uses, it subtly fills in the blanks and the missing pieces that I haven't cemented in my brain yet thus making me miss out of the opportunity to do so.

And it steals the accomplishment of the final thing existing. I don't feel an accomplishment by typing in google "I need a C# to C transpiler" and just downloading it. That's what LLMs feel like, even if I'm trying to steer them at a lower architectural level. I don't have the aha moments, I don't have the learnings, and I'm disconnected from the code.

Thus it feels like it's stealing all the intrinsic rewards from me, only leaving the extrinsic ones. And those are not rewards I am particularly motivated by.

We are all motivated by different things and being extrinsically motivated isn't a bad thing at all.

But being more interested in the problems rather than the solutions (and not wanting to "productize the solutions") is why LLMs are demotivating for me.

I got into coding over a decade before it was my career because of the exploration, learning, and puzzle/challenge aspect.

Every time I have tried to be extrinsically driven (career or OSS wise) it's never worked out anyway. I could have done more to make it successful but I never cared about getting validation or getting users for my stuff (and the stress that brings).

I've been lucky that up until this point, the intrinsic rewards I have gotten from my job have aligned with company goals.

LLMs take all the intrinsic wins and leaves only the extrinsic ones. That makes me sad, but it is what it is I guess.

I have been thinking about a tool for months but didn't have the time. I finally gave in and built it at work in a week with LLM tokens. It worked fantastically. But I felt no accomplishment. It felt just the same as if I downloaded the tool from someone else's repo (and who had an overly eager maintainer that would implement my GitHub issue requests).

The hard part for me is ignoring LLMs in my free time to try and keep some of the intrinsic rewards to myself, without being annoyed that I could do it faster if I just "gave in".

In reality I fear it's going to cause less copyright protections even for small developers.

The LLM is not employed by you or your employer, because you can't enter contracts with non human or non human organizations.

When you license a non-LLM code generation service (like a page that creates a website for you), that company owns the copyright of the generated website because their deterministic system generated code by defined rules and mechanisms that were defined by the code generation system. Assuming no LLM as part of that, there is no code that is generated by the system outside of the rules that they defined (it's not filling in the blanks that you or the code generation system didn't explicitly define).

Since they own the copyright of the website, they can then assign the copyright and authorship to you because of your license agreement to them.

Since the LLM is filling in the blanks on its own in undefined ways, it is the author and not Anthropic/OpenAI/ETC. That means that even though you have a license agreement with Anthropic/OpenAI/etc.. to transfer copyright, they didn't have copyright/authorship, the LLM did. And since the LLM can't legally own copyright/authorship (since it isn't a human) then it can't grant it to you and you can't then grant it to your employer.

The employees and contractors are the authors, and because of the contract they sign they assign copyright to the corporation. Corporations, as a collection of humans are allowed to have authorship.

LLMs are not companies and they are not humans in any way shape or form, and thus cannot get copyright nor grant copyright to a third party.

There problem is the LLM is still making assumptions on that line of code and thus it's still the main author (based on existing case law and the copyright office's opinion currently).

The markdown case is definitely more like the case I cited where the supreme court decided that specficiations and back and forth do not mean it's a deritive work and thus the actual implementor is the author, not the spec writer.

While it's not code related, the copyright office's opinion is a good read and I don't see any reason to believe it's opinion is different for works of text vs works of physical art: https://www.copyright.gov/ai/Copyright-and-Artificial-Intell...

The case Community for Creative Non Violence Vs Reid (https://en.wikipedia.org/wiki/Community_for_Creative_Non-Vio...) solidifies a supreme court opinion that someone contracting a work and directing an author does not grant authorship to the commissioner of the work, it grants authorship to the person actually doing the work.

The author can grant authorship and copyright to the commissioner with a contract, but the monkey picture (and others) have solidified that only humans can be granted copyright. Since LLMs aren't human they can't hold copyright, and if the LLM doesn't have legal copyright then they don't have legal rights to assign copyright to you.