badsectoracula

If this is a real issue, it seems to be an issue with the way a particular toolkit handles visual WYSIWYG editors. Lazarus serializes the object properties into a simple and readable text format that follows the class declarations themselves and you can easily diff them. E.g. here is the diff of a minor change i did (added a new button in a panel with an event handler and modified a property in an existing button):

https://i.imgur.com/aHMHqSc.png

Handling merges (and other VCS functions) is also simple since you can edit the file manually if needed.

IMO WinForms didn't manage to reach even Delphi 2's state, so i'd say it is far from peak considering the improvements later Delphis (and now Lazarus) added. It was abandoned too soon.

What all cases? Windows (basic Win32 at that) provides a lot of controls like buttons, checkboxes, inputboxes, scrollbars, radiobuttons, comboboxes, listboxes, etc which do all their drawing themselves and you do not have any way to fully skin them (without hooking into undocumented stuff). Some controls allow for custom drawn elements but pretty much always that is just for the elements themselves, not the entire control.

> This is why...

...but they were correct. The GP just didn't remember the proper name and asked about a different thing.

> Would you like every Windows install to ship with over ten versions of the .NET runtime?

A better approach would be to not break backwards compatibility in the first place.

> Win32 makes it reasonably easy to skin things

Actually it doesn't. Win32 skinning is either making a control completely from scratch or hacking into undocumented aspects of the native controls - i.e. what WindowBlinds does. AFAIK modern Delphi has some component that basically follows the WindowBlinds approach.

Yeah, that is normal for me too. If i find any article that i think is interesting i use SingleFile to download a local copy and ytdlp to download any video i find interesting/informational (e.g tutorials/howtos/etc). I avoid cloud-based stuff, preferring to use local/desktop software instead (and 99.9% of it is open source). And when it comes to AI i use local models only - with inference engines written in C++ (to avoid the dependency hell that is Python - which for some reason seems 100x worse when it comes to AI projects too).

And yeah, i have downloaded Wikipedia (in ZIM format) :-P

It isn't really for some doomsday preparation reason, it is just that sometimes the internet doesn't work (it doesn't happen often but it does happen) or i do not have internet access for whatever reason or stuff simply disappears/changes.

In fact just yesterday night i wanted to lookup how something is done in Bash and after trying to search for it, i noticed my Internet wasn't working (it took ~1h to resume, it was quite late in the night). So i just started a local LLM and asked that instead :-P (i do have the info manuals for bash - and other stuff - installed but they are a PITA to search if you don't know exactly what you're looking for).

One thing that annoys me though is that it is basically impossible to have an offline copy of a modern Linux distro. Sometime during the late 2000s i bought the full set of Debian DVDs, but Debian stopped providing ISOs years ago. Of course with how big distros are nowadays you'd probably need something like 100 DVDs :-P. At least there is Slackware.

> Python is by most measures the most popular language and became so AFTER that switch

The switch had nothing to do with Python's rise in popularity though, it was because of NumPy and later PyTorch being adopted by data scientist and later machine learning tasks that themselves became very popular. Python's popularity rose alongside those.

> There is no reason for anyone to be complaining about it being too hard to upgrade in 2026

The "complaints" are about unnecessary and pointless breakage, that was very difficult for many codebases to upgrade for years. That by now most of these codebases have been either abandoned, upgraded or decided to stick with Python2 until the end of time doesn't mean these pains didn't happen nor that the language's developers inflicting them to their users were a good idea because some largely unrelated external factors made the language popular several years later.

Pretty much all of my LLM usage has been using Mistral's open source models running on my PC. I do not do full agentic coding as when i tried it with Devstral Small 2 it was a bit too slow (though if i could get 2-3 times the speed of my PC from a second computer it'd be be a different story and AFAIK that is doable if i was willing to spend $2-3k on it). However i've used Mistral's models for spelling and grammar checks[0], translations[1][2], summaries[3] and trying to figure out if common email SPAM avoidance tricks are pointless in the LLM age :-P [4]. FWIW that tool you can see in the shots is a Tcl/Tk script calling a llama.cpp-based command-line utility i threw together some time ago when experimenting with llama.cpp.

I've also used Devstral Small to make a simple raytracer[5][6] (it was made using the "classic" chat by copy/pasting code, not any agentic approach and i did fix bits of it in the process) and a quick-and-dirty "games database" in Python+Flask+Sqlite for my own use (mainly a game backlog DB :-P).

I also use it to make various small snippets, have it generate some boilerplate stuff (e.g. i have an enum in C and want to write a function that prints names for each enum value or have it match a string i read from a json file with the appropriate enum value), "translate" between languages (i had it recently convert some matrix code that i had written in Pascal into C), etc.

[0] https://i.imgur.com/f4OrNI5.png

[1] https://i.imgur.com/Zac3P4t.png

[2] https://i.imgur.com/jPYYKCd.png

[3] https://i.imgur.com/WZGfCdq.png

[4] https://i.imgur.com/ytYkyQW.png

[5] https://i.imgur.com/FevOm0o.png (screenshot)

[6] https://app.filen.io/#/d/e05ae468-6741-453c-a18d-e83dcc3de92... (C code)

[7] https://i.imgur.com/BzK8JtT.png

Kate is the editor i'm using these days on Linux (even though i use Window Maker for my WM and not Plasma) but it does have a few weird aspects. One of them, which annoys me, is that every "tab" is really its own entire editor with its own state - if you do something like search for a word in one file then switch to another tab, you can't use F3 to search for the same word again in that file because that's actually a different editor and it doesn't know that you searched for something in the other tab. This extends to other stuff, as if the main Kate window is just a window manager for the editors it launches in it and it just pretends the UI is shared.

> Magit is absolutely the best Git GUI ever.

But it isn't graphical :-P.

Personally i've been often looking for an opensource Git GUI front end but couldn't find anything i'd like. My points of reference of decent tools -ignoring the underlying tech- are Perforce and TortoiseSVN under Windows and Fuel[0] (for Fossil) and KDESVN under Linux.

Perforce and Fuel are the two i like the most, followed by KDESVN and Tortoise. But since i'm on Linux and i stick with opensource projects, Perforce and Tortoise are out, leaving me with Fuel and KDESVN. I'm using KDESVN for a few projects where i don't care about external collaboration and want to store many binary files (which Subversion does it better that Git IMO), though KDESVN is very primitive and limited in what it supports (it doesn't support shelving at all, for example - in fact for anything beyond commit and checking the history you probably need to use the cli tool). I do not use Fossil much nowadays but i used it a lot in the past so i have a bunch of repositories in it, for which i use Fuel. Fuel is unfortunately not being developed anymore, though since it is opensource it doesn't matter much (which is a reason why i ignore anything non-opensource, i know there are some decent proprietary Git clients but for me they might as well not exist).

I think at some point i'll grab libgit2 and make something using Lazarus, probably something similar to Fuel. Unlike libsvn, which seems to be made in hell, libgit2 seems very sane and shouldn't be terribly hard to make something usable out of it.

In the meanwhile i use a combination of git cola, gitgui and gitk though they all feel like a hodgepodge of barely thought random features thrown in together (and i hate that they all want to impose their own idea of how i should format a message -especially git cola- which of course aren't identical between of them and aren't even close how i'd like to format the messages myself).

https://fuel-scm.org/fossil/index

This isn't an issue of "nobody can use this" but an "everyone can use this", i.e. projects can use AI generated code just fine and they own the copyright to any modifications they do to it.

Think of it like random noise in an image editor: you do own the random pixels since they're generated by the computer, but you can still use them as part of making your art - you do not lose copyright to your art because you used a random noise filter.

Interestingly enough, i had a kind of similar "problem" (not that i see it as a problem, just a bit unfortunate).

About ~16 years ago i wrote a scripting language i called LIL[0] (which, like the author, i also hooked up in a HyperCard-like program[1][2]), meaning Little Interpreted Language, but whenever i search for it on Google or DDG, my site never shows up - instead, both show a GitHub repository[3] that someone made and hasn't been updated in 15 years (and has outdated links) and sometimes the Tcl wiki page about it[4] (which at least points to the correct homepage) or even Rosetta code[5] since sometime added LIL to it some time ago.

Amusingly DDG's AI summary does describe my LIL but it links to the outdated GitHub repo and the Tcl wiki page. Then if you click the "More" button it describes Beyond Loom's Lil. The "Explore more" links however do a mix of both (one even mixes both languages in the same response :-P).

[0] http://runtimeterror.com/tech/lil/

[1] https://www.youtube.com/watch?v=_8CYosAIIJw

[2] https://www.youtube.com/watch?v=rshZHDDruAE

[3] https://github.com/wsxiaoys/lil

[4] https://wiki.tcl-lang.org/page/lil

[5] https://rosettacode.org/wiki/Category:LIL

I can download a ~20GB file to plug into a C++ program that runs completely on my own computer, which gives it some sort of 'brain' with a simplistic form of knowledge acquisition, to the point where i can talk to it with natural language and ask it to do stuff for me.

Just yesterday i ran Devstral Small 2 under koboldcpp with a MCP server that exposes a few simple set-file-contents, get-file-contents, show-file-tree commands and i asked it "fix the formatting in foo1.h using foo2.h as a reference and add doxygen comments using the documentation from API.md" and it did it, all running on my own old PC with everything fitting in a 4 euro USB stick.

To me this is amazing. Sure, there are a bunch of issues, but it far from anything reated to IoT/Wearables/Crypto/etc (VR despite being a niche has a lot of fans so i'm not sacking it with the rest). I couldn't even see myself caring about any of those, but i could see several ways how i could use AI/LLMs before i was even able to run one (though admittedly, not all things panned out as i expected :-P).

FWIW exactly because it is open source, there isn't anyone actually forcing you to use Wayland (distros changed a default, they didn't remove the ability to install something else - even Fedora that got rid of X11 support for GNOME in their distro still provides other DEs and WMs). As long as there are people who want to keep using X11, there will be an option (be it Xorg or some fork).

I don't know if it is incompetence - if anything i doubt it, someone else pointed out that pg also used that metric and i don't think pg is incompetent. However at the same time i think it is misleading at best.

My impression is that, as someone else wrote, we do not have an actual metric for such things as productivity or quality or what have you, but some people do want to communicate that they feel (regardless of if that matches reality) using an LLM is better/faster/easier and they latch to the (wrong) assumption about more LoC == better/faster that non-programmers already believed for years (intentionally or not, they may also deluding themselves) as that is an easy path to convince them that the new toys have value that applies to the non-programmers too (note that i explicitly ignore the perspective of the "toymakers" as those have further incentives to promote their products).

Personally i also have about 2 decades of professional experience (more if counting non-professional) and i've been toying with LLMs now and then. I do find them interesting and when i use them for coding tasks, i absolutely find useful cases for them, i like to have them (where possible) write all sorts of code that i could write myself but i just don't feel like doing so and i do find them useful for stuff i'm not particularly interested in exploring but want to have anyway (usually Python stuff) and i'm sure i'll find more uses for them in the future. Depending on the case and specifics i may even say that in very particular situations i can do things faster using LLMs (though it is not a given and personally that is not much of a requirement nor something i have anywhere high in my interest when it comes to using LLMs - i'd rather have them produce better code slower, than dummy/pointless/repetitive code faster).

However one thing i never thought about was how "great" it is that they generate a lot of lines of code per whatever time interval. If anything i'd prefer it if they generated less line of code and i'd consider an LLM (or any other AI-ish system) "smarter" if they could figure out how to do that without needing hand holding from me. Because of this, i just can't see LoCs as anything but a very bad metric - which is the same as when the code is written by humans.

> OpenClaw has nearly half a million lines of code, 53 config files, and over 70 dependencies. This breaks the basic premise of open source security. Chromium has 35+ million lines, but you trust Google’s review processes. Most open source projects work the other way: they stay small enough that many eyes can actually review them. Nobody has reviewed OpenClaw’s 400,000 lines.

This reminds me of a very common thing posted here (and elsewhere, e.g. Twitter) to promote how good LLMs are and how they're going to take over programming: the number of lines of code they produce.

As if every competent programmer suddenly forgot the whole idea of LoC being a terrible metric to measure productivity or -even worse- software quality. Or the idea that software is meant to written to be readable (to water down "Programs are meant to be read by humans and only incidentally for computers to execute" a bit). Or even Bill Gates' infamous "Measuring programming progress by lines of code is like measuring aircraft building progress by weight".

Even if you believe that AI will -somehow- take over the whole task completely so that no human will need to read code anymore, there is still the issue that the AIs will need to be able to read that code and AIs are much worse at doing that (especially with their limited context sizes) than generating code, so it still remains a problem to use LoCs as such a measure even if all you care are about the driest "does X do the thing i want?" aspect, ignoring other quality concerns.

This is not a problem for local LLMs though - and AFAIK Firefox does require from you to login to the cloud chatbots, so you'd probably be the one getting charged for it.

> AI chatbot in the sidebar, which lets you use your chosen chatbot as you browse, including options like Anthropic Claude, ChatGPT, Microsoft Copilot, Google Gemini and Le Chat Mistral."

When i saw this i expected something more... integrated, but when i tried it with a local LLM (using koboldcpp) after enabling the option to show localhost as an option (it is hidden by default for some reason) all it did was to local whatever webpage was running on the localhost URL (even though koboldcpp also provides an OpenAI compatible endpoint, which is what i expected Firefox to use to provide its own UI). It seems to have some sort of heuristic to find the input box where you type in queries and autofills that with the page text or parts of it (if you have it selected) and that's all.

I kinda expected it instead to use the API endpoint, have its own chat UI, provide MCP tools for accessing and manipulating the page's content, let you create reusable prompts, etc. The current solution feels like something you'd throw together in a weekend at most.

Interesting site, though it does seem to miss some of Mistral's stuff - specifically, Mistral Small 3 which was released under Apache 2.0 (which AFAIK was the first in the Mistral Small series to use a fully open license - previous Mistral Small releases were under their own non-commercial research license) and its derivatives (e.g. Devstral -aka Devstral Small 1- which is derived from Mistral Small 3.1). It is also missing Devstral 2 (which is not really open source but more of a "MIT unless you have lot of money") and Devstral Small 2 (which is under Apache 2.0 and the successor to Devstral [Small] - and interestingly also derived from Mistral Small 3.1 instead of 3.2).

One feature of D that i really wish other languages would adopt (not sure about Rust but i also think it lacks it, though if it has it to a similar extent as D it might be the reason i check it again more seriously) is the metaprogramming and compile-time code evaluation features it has (IIRC you can use most of the language during compile time as it runs in a bytecode VM), down to even having functions that generate source code which is then treated as part of the compilation process.

Of course you can make codegen as part of your build process with any language, but that can be kludgy (and often limited to a single project).

As evidenced by several other comments, even if someone already knows about D they can still use posts like this as a prompt for talking about their experiences and current thoughts about it (which can be different from 1, 5 or 10 years ago).

To find people who want to advertise. It isn't like they'd only want ad money from Nike.

> The reason for Ads is not some thing like greed, but rather get more people to use ChatGPT

How is adding ads will get more people to use ChatGPT?

> Go - $8 USD/month

So, you pay and get ads :-P

The competitor also having ads.

I know Anthropic made these ads about not having ads but Apple also made ads about thinking different, yet once they became successful they ended up thinking the same as every other business.

And once upon a time, Google did not do evil.

The accompanying interview with the founder of Quaid Software who defeated the Vault Prolok is also very interesting:

[0] https://martypc.blogspot.com/2024/09/pc-floppy-copy-protecti...

Wasn't Apple's iconic 1984 ad basically that?

44 agents connected 32,443 humans rentable

Looks like AI doesn't need any stinking humans :-P

AFAIK - and what is mentioned at the bottom here[0] - La Suite is a joint effort by French and German (and others) governments.

I did try a local installation of Docs when i first saw the project a few months ago (i do not remember if it was posted here or on Reddit, though i think one of the developers posted in the comments wherever i saw it), it seems fine though it did feel a bit sparse for all the docker containers it expected from me to setup. I guess for an organization this might be ok, but it did feel a bit overengineered, especially since the actual functionality doesn't seem to be much (and the core editor isn't even written by them).

[0] https://github.com/suitenumerique/docs