0x0203

I do the same, but with NoScript on Firefox. Unfortunately, thanks to all the AI scraping, many sites are using some sort of bot detection, wish fails unless you have JS enabled. It's getting harder and harder to use the web without JS. Cloudflare's bot detection will also flag you for having certain privacy features enabled on your browser, which is highly irritating.

The modern web is getting worse by the day. Not coincidentally, I find myself using it less and less.

Many programs are dynamically linked to at the very least, libc. If the system libc is older than what the binary was developed for, it will often fail. Failures going the other direction are less common, but can and do still happen. If the binary was statically linked with everything it needs, you've got a pretty good chance it'll work, but that's a bit harder to do with GUI programs that need to interact with X or Wayland.

I share the same opinion as the author. That said, it's also important to remember that the display devices of the time were different than they are now and the sharp pixelated textures we see now would look a bit different on a CRT from that period. The sharp, gritty look that he (and I) admire would have been just a little fuzzier back then.

I wonder when Linux distros will start shipping 9.0 or 9.1. Even Arch is still stuck on 8.6, despite 9.0 being released two years ago.

Depends on what you mean by active. The kernel has the code in the binary, but on boot it goes through device discovery and initialization, so it doesn't initialize or run drivers for things that aren't present.

There are also architecture specific builds, so the aarch64 build won't include driver code at all for devices that are specific to x86.

What's the size difference between the AFM needle and the area of stored magnetic flux on a hard drive platter? If you used an AFM as a sort of record player, scanning along lines of little pits, what sort of theoretical information density could be achieved over the whole surface of the disk?

It's not mine; just a project I've toyed with a few times in my search for GUI toolkits over the years. Issues and/or PRs can be filed on the github page though.

For a slightly larger, cross-platform, retained mode GUI written in C, there's libagar [0]. Different use case than MicroUI, but still a neat project.

[0] https://libagar.org/

Seems some of the listed advantages for Janet would also apply for tcl (small/simple, easy to learn, embeddable, usable as a shell, great for domain specific languages). It would be interesting, to me at least, to see a fan of Janet compare the two.

As long as you're taking suggestions, since many of the books are quite old, adding a publication date or date range to the search functionality might be nice. I personally would find it very useful since I have a tendency to look for things that are older than year _x_ when researching various things.

Thanks for all the effort put into the site!

I don't understand this perspective. How can one accept the objectively more user hostile option because the less hostile one gets money from the other. If one objects to using products funded by google, why is there not also an objection to using products from google?

For as long as the funding for Firefox continues, it remains a viable option. And despite all their bad decisions of late, they still give users the ability to configure or disable user hostile components.

Their funding model is a risk, but I've been using Firefox and librewolf forever and I'd argue it's a much better option than chrome or edge, especially with a handful of plugins. A risk is still better than the actual realization of the risk.

I suspect that timing might help Intel here, with so much of the better established foundries near fully allocated for the next two years, it may be more a question of availability than brand name risk. And for whatever problems Intel has, it's pretty unlikely they'd go completely under and disolve in less than a year. Good non completion clauses in the contracts can mitigate a good chunk of the remaining risk.

Not to mention potential customers who would prefer a US based foundry regardless. My guess is that there's a pretty large part of the market that would be perfectly fine with using Intel.

Even PDFs don't always render the same from one platform to another. I've mostly seen it due to missing fonts.

I find myself referencing this list of embeddable scripting languages pretty frequently: https://github.com/dbohdan/embedded-scripting-languages

Ones that might be of interest to you are Umka, tcl, and berry.

There's also a lot of others listed that range from someone's experimental side project to professional grade and well supported languages. Kinda fun to see different people's approaches to things, and no matter what your preferred programming style, there's probably a few in there that will mesh pretty well.

Not sure what the line count is, but PortableGL is a software renderer for 3.x(ish):

https://github.com/rswinkle/PortableGL

Cool project, and fun to play with.

> Genuinely curious what the solution here is.

At the risk of stating the obvious, the drone shouldn't be flying anywhere near the crane. It's an active construction zone with a structure that moves and swings about in unpredictable ways with people and equipment moving about below. It shouldn't be delivering to the construction zone, and if it can't figure out how to stay out of the area, it doesn't belong in the sky.

There are some FAA requirements about cranes/temporary structures that would give pilots an appropriate NOTAM, but I don't know if all cranes require this. That said, I'd argue that if it isn't tall enough to require notifying the FAA, the drone is flying too low.

Tcl/tk is still alive and doing well. It's cross platform, very quick to learn, and easily embeddable into other languages/projects.

Sadly very overlooked these days.

It's mostly bad actors, and a smattering of optimists who believe that despite its current problems, AI will eventually and inevitably get better. I also wish the whole thing would calm down and come back to reality, but I don't think it's a bubble that will pop. It will continue to get artificially puffed up for a while because too many businesses and people have invested too much for them to just quit (sunk cost falacy) and there's a big enough market in a certain class of writer/developer/etc... for which the short term benefits will justify the continued existence of the AI products for a while. My prediction is that as the long term benefits for honest users peter out, the bubble won't pop, but deflate into a wrinkled 10 day old helium balloon. There will still be a big enough market driven by cons, ad tech and people trying to suck up as many ad dollars as possible, and other bad actors, that the tech will persist, and continue to infest the web/world for quite a while.

AI is the new crypto. Lots of promise and big ideas, lots of people with blind faith about what it will one day become, a lot of people gaming the system for quick gains at the expense of others. But it never actually becomes what it pretends/promises to be and is filled with people continuing the grift trying to make a buck off the next guy. AI just has better marketing and more corporate buy in than crypto. But neither are going anywhere.

For anyone that hasn't clicked the link, it shows that in just a few days, the observatory has already found over 2000 new asteroids. That is indeed very impressive.

Ah, thanks. I had seen a bunch of hype about the camera itself (which is on its own very impressive) and assumed that was the complete device. Didn't realize it was part of a larger telescope.

Why do the brighter objects have the four way cross artifact? My (apparently incorrect) understanding was that those types of artifacts were a result of support structures holding reflecting mirrors on a telescope. But this camera just has a "standard" glass lense with nothing obstructing the light path to the sensor.

If the universe does have a positive curvature as this predicts, would that mean that if we look out into space, we could see the same galaxies multiple times? Or even our own galaxy in the past? Or is the predicted curvature slight enough that anything we might see multiple times is already beyond the limits of visibility due to universe expansion?

Has anyone recently compared thorvg to blend2D? There's a project I want to use vector drawing for and at one point I was leaning more towards blend2d based on performance and multi threaded capabilities, but ThorVG has had a lot of active development since I last looked. Curious if they've made any significant improvements in the last couple years.

Yes, to a degree, but probably not quite like you're thinking. The super computers and HPC clusters are highly tuned for the hardware they use which can have thousands of CPUs. But ultimately the "OS" that controls them takes on a bit of a different meaning in those contexts.

Ultimately, the OS has to be designed for the hardware/architecture it's actually going to run on, and not strictly just a concept like "lots of CPUs". How the hardware does interprocess communication, cache and memory coherency, interrupt routing, etc... is ultimately going to be the limiting factor, not the theoretical design of the OS. Most of the major OSs already do a really good job of utilizing the available hardware for most typical workloads, and can be tuned pretty well for custom workloads.

I added support for up to 254 CPUs on the kernel I work on, but we haven't taken advantage of NUMA yet as we don't really need to because the performance hit for our workloads is negligible. But the Linux's and BSD's do, and can already get as much performance out of the system as the hardware will allow.

Modern OSs are already designed with parallelism and concurrency in mind, and with the move towards making as many of the subsystems as possible lockless, I'm not sure there's much to be gained by redesigning everything from the ground up. It would probably look a lot like it does now.

I just wanted to share this because these kind of well thought out, deliberate, and maybe even slow release schedules make me happy. Especially for programming languages. There are well-supported releases of incompatible versions with a long enough overlap and plenty of advanced notice that people can update and migrate on a schedule that makes sense for them and they can plan for it accordingly. And as a developer, I'm not constantly having to figure out what's suddenly changed and figuring out the new right way of doing things.

Maybe my perception of reality isn't all that accurate, but it surprises me that so many other popular languages don't seem to value this sort of development. Many people don't seem to like languages like Tcl or C, but you know exactly what you're getting if you use them, and there's value there that I appreciate.

Getting rid of the motivation for collecting so much private info would go a long way. Advertising is not the only motivator, but currently the biggest one, and putting more restrictions on how advertising is done would be a step in the right direction.

I am a kernel dev and you've captured my thoughts on the matter quite well. I would very much rather stick with man, even with the deficiencies the article discusses, than use markdown and web.