robalni

I find it quite annoying that I have to have a monitor plugged in for the upgrade to work. Otherwise it reboots into the old version after downloading. Is this a common problem?

In my opinion, LLMs are not competing with real programmers because they do different things. The job of a programmer requires a lot of responsibility and understanding. Using LLMs to write code does not help with that.

You may say that they do compete because companies treat them as the same thing and people need to make money, so the companies decide what is what. That is true but the solution should not be to give in to the money, but instead to make the money behave correctly.

What we need to do is to fix the economy, which still assumes that products are physical and hasn't been adjusted for the digital reality we have now, let alone the AI. Money was invented by humans, not discovered in nature, and we should therefore make it do what we need instead of letting it steer us the wrong way.

That's basically the comment I was just going to write but you made me not need to.

We need simpler protocols and formats, especially those that are used over the internet. I want everyone to really start fighting for this.

I always use a browser that doesn't run any scripts (w3m) for both this reason and others. It hurts when I see websites that don't work without js. A bit funny though that this page is one of them so I was not able to read it.

I am working on a project that will be like a whole environment bootstrapped from the smallest possible beginning.

I thought a hex-to-binary converter like hex0 was too much like machine code, and I wanted everything to be source code, so I chose to instead start with a super simple interpreted language that is described in english and the user is supposed to write an interpreter for it themselves in any way they want. This way I connect the human to the computer using the language of the human which I thought felt better and easier to understand.

This super simple interpreted language then builds a super simple RISC-V assembler. Here I came up with a nice technique where the functions in the assembler are called through pointers, which makes them replacable while the asesmbler is running. So as soon as the assembler has compiled a better version of one of its own functions, that function is then replaced with the better version while the asesmbler is running and it continues to compile the rest of the code which can then use the new features. So it evolves without having to restart.

I wasn't thinking about distractions or being able to concentrate when I asked this. I meant something that exists over longer time, like years. Like, the knowledge that there are so many other things makes it harder to appreciate and care about each of them. There seems to be a similar effect when living in a place where there is a high density of people. They start looking like background noise. But if there are not many people around, you might talk to almost everyone you see.

Trying to answer my own question, one thing that I think has helped me to more appreciate some things, is to have rules and try to enforce them. It could be to use an unusual operating system, or disconnect my computer from the internet, or deciding that there are some types of things or features that may not be used. That has the effect that most things I find online don't pass the rules or don't work for me and therefore I have to care more about the things that do.

So I was wondering how we can achieve this at a bigger scale, unless everyone else want to limit themselves as I do. It's quite fun actually but I don't think people care enough to do this.

I think another reason to write code by hand is that you want to know what you get. If you have an idea, then you can implement it better than an LLM, just like you can implement it better than another person, because you are the only one who understands what you mean exactly. Details are always lost and misunderstood in communication; this is a weakness of LLMs.

Similarly, even if I don't write the code but I let someone else who I trust do it for me, there is value for me in that person not using LLMs, because only if they don't, I can know that the only spirit that lives in the code is of the person of my choice. It's like a social thing; I can know and trust a human, but I'm not sure I can do that with an LLM.

It's similar to how you wouldn't want to use LLMs in politics: the whole point of expressing your ideas is that they are your ideas and if you let someone (or something) else do it for you, details will be missed and misunderstood.

So this is one reason that I think hobby communities don't like LLMs; they care too much about what they build.

Here is my list:

- A server package containing: web server, smtp server, database engine, page generating language and a supervisor that keeps everything alive. All written in C and I use them for all server programming I do.

- A file renamer that can rename multiple files. It puts the filenames in a text file and lets you edit it and then renames the files according to the changes.

- A RISC-V start kit containing a very simple assembler, disassembler and documentation.

- A script that runs twice a day and downloads things from the internet (like weather forecasts, news feeds, podcast feeds, train traffic info), puts them in a folder and does some processing and formatting. Then I can easily go through it all to get my daily information.

The article is about only one side of the solution: using AI to make it easier to work with code.

I think the other side of it is more important: making software simpler so that people can work with the code without having to use AI. That's what I try to do.

There are so many formats and standards and people using different sets of them that I feel like we need an organisation that selects some of them and decides that those are the ones that people should use. Everyone could become a member of that organisation and vote for which standards should be part of the next version of the selected set. Maybe there could be a new version every other year or something.

This would give us some kind of leader that shows the way. It would make it easier for developers if people were more focused on fewer standards and there would be a well defined point in time when we would upgrade to the new set of standards.

For those of you who are familiar with RISC-V, it would be like the RVA23 spec: one big collection of things to use that can be targeted and talked about as one thing with one name, rather than everyone having their own collection of extensions that they use.