Funny feelings in my tummy reading this! I worked with winapi back in late 2000s to early 2010s and I remember having some great fun with it. Although there was MFC and WPF I didn't want to learn them because I wanted the fastest & leanest (catch the reference :) executable I could get; I'd then run gnu strip over the .exe too.

Stack Overflow was essential to figure out arcane flags that could solve my issues (when even MSDN, another great site with its examples, couldn't) and Raymond was very present in SO at that time, iirc he replied to one of my questions too. That's when I found his blog, always great reads!

Now I've been a 14-year Linux user and none of the toolkits and libraries give anything close to the winapi experience.

> fastest & leanest

Surely you mean leanest and meanest :P

I'd also say that tooling on Windows is simultaneously better and easier to use than on Linux; the noob case of green play button in an IDE is taken care of, but if you want detailed performance and memory profiling, record-replay debugging, hot-reload, all of this is straightforwardly available on Windows.

Oh good I thought I was doing something wrong! Using ChatGPT web for planning, ask for a prompt then notice something weird in the prompt and whether I:

1) use the edit in-place functionality; or

2) ask it to rewrite to remove something

It'll write the prompt as if the agent (codex) knew about the conversation and add "don't do X" etc. At first that bothered but I realized it doesn't really change the output so I stopped caring.

Still, no experience is unique I guess.

I always think of Johnny Mnemonic when I see such interfaces. One of the reasons I got into computers as kid. Hackers (1995) also had a great (Hollywood) computer interface that shares some similarities with it.

Same. I just skip verified posts because the ones at the top are LLM replies. Unless I'm missing something, that should be easy to detect. Instead I've got ghost banned for a week+ now, no reason given and no way to appeal. X now is the place if you want to check for yourself the dead internet theory.

Great project! I'm looking for something like this but for code: an app that runs locally and obfuscates variables & strings into generic things, so you don't leak code/db structure to LLM companies. Couldn't find anything though so I'm using an LLM to write one.

Simply yes.

It's true that in specific functions a human can do better than a compiler at optimizing for a target platform (sometimes, not always). That's a place where someone could reasonably drop down to assembly and get better performance.

But the case I'm specifically pointing out, one of inlining, is something that compilers do better than humans. This isn't "propaganda from compiler companies" (btw, not a thing. The most common and popular compilers are opensource and not owned by any single company). There are other cases like this where compilers are just more likely to get things right than humans are. They have a lot of heuristics about common assembly patterns that few humans can be expected to have memorized.

Each of the cases you pointed out are cases where the compiler does a bad job at optimizing a single function for whatever reason. They are not examples of a whole application written in assembly outperforming compiled high level languages. And each of the cases almost certainly took the human a considerable amount of time to figure out and prove their solution was better than the compilers.

What you've done is cherry pick when compilers fail and you are using that as evidence that they always fail.

Compilers sometimes fail, something I'm happy to admit. But on the whole for a whole application the compilers will get a lot more right than a human possibly could because they can output unmaintainable assembly.

You're completely right and I thought this would be obvious. I never prompted anything remotely closely to "make a facebook clone". Instead, I make an explanation of how it should work. To give you an example:

  I need a python script that
  
  1) reads /etc/hosts
  2) find values of specific configured hosts (read from a .conf which) eg server1, localhost, etc
  3) it'll assign a name to those configs eg if the .conf has
  
  [Env1]
  192.168.0.1 production-read
  192.168.0.2 production-write
  192.168.0.27 amqp
  
  [Env2]
  192.168.0.101 production-read
  192.168.0.201 production-write
  192.168.1.127 amqp
  
  Basically format:
  
  [CONFIG_NAME]
  <ip> <hostname>
  
  Like an usual hosts file
  
  4) And each of those will be stored in memory
  5) if in /etc/hosts it matches one of those, it sets the "current env" as the configname
  
  5) It'll create an icon on the top-right of ubuntu 22 default gnome with
  6) that icon could be the text of the current config name or if nothing matches, "custom" text would show
  7) When the user clicks the "tray"/appindicator(or whatever gnome is calling them) it'll list the config names in a   simple gtk/gnome
  8) When the user clicks one config, we create a backup of /etc/hosts in ~/.config/backups/ named   hosts-%UNIX_TIMESTAMP%
  9) we then apply it to hosts file (find only the line with the hostnames to change and modify only those)

And that one-shotted a simple gnome app indicator env switcher. Had to fix a few lines here and there but it mostly just worked. If you give the proper spec to the LLM, it'll do it right. You can even fake a DSL to describe what you want and it'll figure it out.

Juxt's Allium https://juxt.github.io/allium/ is an interesting entry in this 'pseudo DSL' space to define and store system specifications and requirements. I think it's likely that this sort of 'persistent specifications to help bots work correctly' will be a good approach when things finally cool down a bit.

That's the kind of stuff where you would write a few lines of shell script or perl and not bother with the whole GTK stuff. Because GTK would be accidental complexity to the task (unless you used something like zenity).

This is one of the reasons I like the OpenBSD and suckless projects. There are solutions that are technically correct, but are overengineered.

Well I would never write shell because I loathe it's grammar/syntax. I enjoy GUIs and am a heavy mouse user, so the GTK part isn't really an "accidental complexity" but a must have for me. If a LLM can one-shot all the GTK boilerplate it's a win.

That's (as shown in my sample prompt) one great thing I've been using LLMs for: making GUIs for arcane Linux-based OS/userland settings that I have no interest in doing "sudo gedit yadda yadda" or learning man pages for. It's been 30+ years, we deserve a better desktop experience.

I've used suckless packages in the past, but it feels to me too close the GNOME/Apple way of giving zero settings and having opinionated defaults whose opinions do not ring well for me. I have zero desire to change my shortcuts/hotkeys to something random devs chose based on their past computer experience, mostly unix-based. Muscle memory > *.

And that’s fine.

I was pointing out that a simpler solution exists. I prefer simple solutions, because I want to test whatever idea I have in real world situation first before I go for a more complete one. Kinda like doodling before committing to do a sketch (or spend weeks doing a painting).

> It's been 30+ years, we deserve a better desktop experience

That desktop experience would need to be like smalltalk (where it’s trivial to modify the gui). The nice power of Unix is having the userland being actually a userland. Meaning you can design a system for your workflow and let the computer take care of that. Current desktop environment doesn’t allows for that kind of flexibility.

Also it’s the nature of unix that makes such basic utilities possible (and building them with raw xlib or tcl is easier than gtk). Imagine doing the same on macOS or Windows where everything is behind an opaque database where some other process fancies itself as its owner.

There's also a pattern based on the simple solution that used to be more common: One command-line program for updating and querying the current state, and a second GUI one that just acts as a dumb interface for the first one. Even aside from separation-of-concerns purity, there are two more practical benefits: this gives you scriptability (say, automatically choosing an environment on startup) as well as easier support for multiple desktop environments (two different dumb GUI frontends for the actual complexity in the command-line backend, or updating the GUI because of a change in the APIs without worrying about breaking the important logic).

Experience has taught us that the two operating modes are different enough by nature, that you need slightly different APIs for each (look at tools wrapping CLI programs: they generally suck one way or another).

What the industry settled on is building an API (library or service) around the data model and business logic, and then building UIs on top.

When done well, UIs are relatively shallow wrappers around the library, but do allow being creative about the UX too.

That's easily more spec than script.

> You're completely right

I mean, no comment

Lol if you know you know (I'm becoming paranoid... I think... help)

I'm interested in seeing a plot of that percentual over the years. The past 3 or 4 years I've been seeing less and less tech savvy comments over here and this data seems a great way to find out if it's just placebo.

And then the new car no longer has the camera where you need it, the panel buttons changed, the cup-holder is in another place. Even worse, the upgraded firmware & OS of the car no longer comes with an app you needed; or it does, but removed a feature that was essential for your daily use. All because some SWE takes "computer security" as more important than having an useful system.

It's the kind of rhetoric that enables shoving down user-hostile features during a simple update. And breaking many use cases. Quite common in the FOSS/Linux mentality, not so much on the rest of the world.

DuckDuckGo insists on shoving "AI Assist" entries in its results, so I have a reasonable idea of how often LLMs are completely wrong even given search results. The answer's still "more than one time in five".

I did not suggest using Google Search (the company's on record as deliberately making Google Search worse), but there are other search engines. My preferred search engines don't do the fancy "interpret natural language queries" pre-processing, because I'm quite good at doing that in my head and often want to research niche stuff, but there are many still-decent search engines that do, and don't have ads in the results.

Heck, you can even pay for a good search engine! And you can have it redirect you to the relevant section of the top search result automatically: Google used to call this "I'm feeling lucky!" (although it was before URI text fragments, so it would just send you to the top of the page). All the properties you're after, much more cheaply, and you keep the information about provenance, and your answer is more-reliably accurate.

> Heck, you can even pay for a good search engine!

Can you recommend one?