pixelfarmer

Even Samsung is running into this issue now [...]

These large corpos are so greedy to the point they harm themselves. I remember something similar with Amazon, where the Amazon shop had to redo the whole architecture from some microservice setup back to a monolithic approach because they used AWS and paid these weirdly structured prices like everyone else. Which made running a monolithic architecture under such constraints inherently cheaper. Not sure what the resulting compounded business cost for this "endeavor" was, but more often that not such things are never accounted for, so they don't show up as an issue.

Which is why humans use tech and tricks to get things done. Gravity Blast is one example: https://www.youtube.com/watch?v=ir_KZNsTNiQ

If you have a large set of lets say floats in the range between 0 and 1 and you add them up, there is the straightforward way to do it and there is a way to pair them all up, add the pairs, and repeat that process until you have the final result. You will see that this more elaborate scheme actually gets a way more accurate result vs. simply adding them up. This is huge, because there is a lot of processing done with floats where this inherent issue is entirely disregarded (and has an impact on the final result).

Donald Knuth has all of that covered in one of his "The Art of Computer Programming" books, with estimations about the error introduced, some basic facts like a + (b + c) != (a + b) + c with floats and similar things.

And believe it or not, there have been real world issues coming out of that corner. I remember Patriot missile systems requiring a restart because they did time accounting with floats and one part of the software didn't handle the corrections for it properly, resulting in the missiles going more and more off-target the longer the system was running. So they had to restart them every 24 hours or so to keep that within certain limits until the issue got fixed (and the systems updated). There have been massive constructions breaking apart due to float issues (like material thicknesses calculated too thin), etc.

It’s like saying sunglasses protect you from the sun

It is actually much closer than you think. There are the standard sunglasses and then you have actually rated sunglasses for various purposes. The more extreme the environment, the more the former gives a false sense of safety that just isn't there.

There can be verification for such things.

Your spine doesn't care why an ejection happened.

the primaries are defined by the display, not by ambient illumination

In itself that is correct, but as you've noted, our own vision system isn't operating like that. The same display brightness and colors will be perceived very differently depending on the ambient light's brightness and color, and can also mean a severe breakdown in the dynamic range that can be made visible via a display.

And this ambient light also clearly impacts how prints are seen.

The problem is that it permeates writing in so many places. For example, games get more and more littered with this sort of nonsense, too. And worse, it is often also used as a vehicle to convey all sorts of ideologies. Many people don't care about these ideologies, but they get annoyed fast if someone shouts them into their face like a zealot. Plus it feels just fake, completely artificial.

The other problem with it: To me, as an adult, it feels like whoever wrote this made the assumption I'm stupid. This sort of writing is ok, up to a certain degree, for kids. But for adults? A lot of anime are aimed at the younger generations. Anime written for adults are done very differently.

The Matrix is heavily influenced by manga / anime, which you see in quite a few scenes in how they are shot. But many of the explanations that are done are part of the development of Neo, so they never really feel out of place.

Cyberpunk 2077, which does have on the nose dialogue here and there as part of random NPCs spouting stuff. But by and large it tells a story not just through dialogues but also visually. And the visual aspect is so strong that some reviewers completely failed at reviewing the game, they were unable to grasp it. Which is a huge issue, because we are talking about adults here.

I haven't read the actual paper, but alone from the abstract many questions come up.

Personally, I doubt the any "near" to "mid" term population decline will have larger effects on the climate change we are seeing. It is just too slow. Meaning that we certainly get (much!) larger effects about climate change done with other stuff, no doubt about that.

However, using that as an inverse argument to foster population growth is a stupid idea, because more people means more resources needed for everything, starting with food and water, climate change resistant shelter, and all the other stuff that is needed for actual living. All of that isn't created out of thin air. Considering that there is increased pressure just to provide food and water already (climate change anyone?!), the lower the population in the long run is, the better. Also, food supply destroys a lot of our environment, alone the meat industry is a planet wide killer because of that.

If I add all this up, population decline is a good thing. And if I read something like "Meanwhile, a smaller population slows the non-rival innovation that powers improvements in long-run productivity and living standards" I start to question the sanity of the people writing something like that.

It is like Sim City 1 where crossroads generated traffic, so you'd replace them with parks.

It can, but it requires the track to be free in front of it and being allowed to go at the required speed to catch up.

If I look at one of the photography books in my shelf, they are even talking about 18 stops and such for some film material, and how this doesn't translate to paper and all the things that can be done to render it visible in print and how things behave at both extreme ends (towards black and white). Read: Tone-mapping (i.e. trimming down a high DR image to a lower DR output media) is really old.

The good thing about digital is that it can deal with color at decent tonal resolutions (if we assume 16 bits, not the limited 14 bit or even less) and in environments where film has technical limitations.

There is no system that fulfills your requirements.

It is even easy to explain why: Humans are part of all the moving pieces in such a system and they will always subvert it to their own agenda, no matter what rules you put into place. The more complex your rule set, the easier it is to break.

Look at games, can be a card game, a board game, some computer game. There is a fixed set of rules, and still humans try to cheat. We are not even talking adults here, you see this with kids already. Now with games there is either other players calling that out or you have a computer not allowing to cheat (maybe). Now imagine everyone could call someone else a cheater and stop them from doing something. This in itself is going to be misused. Humans will subvert systems.

So the only working system will be one with a non-human incorruptible game master, so to speak. Not going to happen.

With that out of the way, we certainly can ask the question: What is the next best thing to that? I have no answer to that, though.

I will tell you one example with inheritance: The Linux kernel.

Doesn't need video anymore, high end cameras can run wild on taking picture after picture and start doing so before you even fully pressed the shutter, to account for human delays and the ones of the tech itself.

I mean we are talking about a part of photography where even back in the days of film a camera would run through a roll of film in seconds for exactly this sort of thing.

If I see something like "At least on Linux, long and long long are both 64 bits in size." my skin starts to crawl. Not only that, but GCC defines __builtin_popcount() with unsigned int / long / long long, respective, i.e. even in the text it should be mentioned correctly (unless a different compiler uses signed types there ... ugh). The call is done with unsigned, using uint64_t as a type-cast, but using a fixed __builtin_popcountl() which translates to unsigned long. There are systems where this will fail, i.e. the only safe bet to use here is __builtin_popcountll() as this will cover at least 64 bit wide arguments.

Also, if a * b overflows within the result type, it is an undefined behavior according to the C standard, so this overflow check is at least not properly portable, either, and the shown code for that is actually buggy because the last A1 has to be A0.

No idea why all that gets me so grumpy today ...

So that is how the US is helping with reaching the climate goals ...

This has a lot to do with framing in photography, architecture, and all these other things where "design" is involved that humans perceive as pleasing. It also means that not everyone has a knack for that. In return, chances are good that there are ways to actually "calculate" it. One well known example: The golden ratio that shows up in many designs, architecture, framing etc.

Memory bandwidth.

It is the thermal envelope that defines pretty much everything nowadays. Without active management of it chips would die a heat death very fast. Which also means chips are designed with a certain chip external heat management in mind. The more heat you can get out of a system and away from a chip, the more powerful you can design these things. And game consoles do have active cooling, i.e. they sit between desktop PCs and thin laptops, probably sharing the thermal handling capacity with larger gaming laptops, if anything.

Then you'll get code that passes the tests you generate

Just recently I think here on HN there was a discussion about how neural networks optimize towards the goal they are given, which in this case means exactly what you wrote, including that the code will do stuff in wrong ways just to pass the given tests.

Where do the tests come from? Initially from a specification of what "that thing" is supposed to do and also not supposed to do. Everyone who had to deal with specifications in a serious way knows how insanely difficult it is to get these right, because there are often things unsaid, there are corner cases not covered and so on. So the problem of correctness is just shifted, and the assumption that this may require less time than actually coding ... I wouldn't bet on it.

Conceptually the idea should work, though.

Even if the tech freezes in place, I think it will yield substantial economic value in the coming years.

The question is, where will this "economic value" be? Because "economic value" and actual progress that helps society are two very different things. For example, if someone wants to hire people, they can use "AI" to sift through the applications. But people looking for a job can also use "AI" to write their applications. In the end you may have created "economic value", but its an arms race and a waste of resources at the core, more digital paperwork, a waste of compute. So the actual value is not positive, it is negative. And we see that in many places where this so called "AI" is supposed to help.

Does it mean it is entirely useless? No, but the field of applications where it actually makes sense and has an overall net benefit is way smaller than many believe.

Plus, there are different types of neural networks in use for decades already. Look at OCR, for example, where the commercial OCR software switched to neural networks around the mid 90s already. So it is not that "AI" as such is bad, just that this generative neural network stuff is overly hyped by people who have absolutely no clue about it, but have to hop on the bandwagon to not be left out and keep shareholder values up, because most of these shareholders are equally stupid about the whole issue. Its a circus that burns many resources, money that could have created way more value in other areas.

Neural networks are generalizing things as part of their optimization scheme. The current approach is just to dump many layered neural networks (at the core) as in "deep learning" to solve the problems, but the networks are too regular, too "primitive" of sorts. What is needed are network topologies that strongly support this generalization, the creation of "meta abstraction levels", otherwise it will get nowhere.

Biological networks of more intelligent species contain a few billion neurons and upwards from that while even the big LLMs are somewhere in the millions of "equivalent" at best. So, bad topology + much less "neurons" and the resulting capabilities shouldn't be too surprising. Plus it is clear that AGI is nowhere close, because one result of AGI is a proper understanding of "I". Crows have an understanding of "I", for example.

And that is where these "meta abstraction levels" come in: There are many needed to eventually reach the stage of "I". This can also be used to test how well neural networks perform, how far they can abstract things for real, how many levels of generalization are handled by it. But therein lies a problem: Let 2 persons specify abstraction levels and the results will be all across the board. This is also why ARC-AGI, while dives into that, cannot really solve the problem of testing "AI", let alone "AGI": We as humans are currently unable to properly test intelligence in any meaningful way. All the tests we have are mere glimpses into it and often (complex) multivariable + multi(abstraction)layered tests and dealing with the results, consequently, a total mess, even if we throw big formulas at it.

Yeah, it is down to the apps, not the phone as a device as such. Engagement driven software exists on consoles and PCs / laptops as well, and I'm not even talking about "social media" stuff, but pretty much all live service games and beyond. In return, I've stumbled over people that cannot even imagine why someone would take a smartphone into a far off-grid area, because for them the phone is synonymous with "always on" and all these stupid apps.

Problem is, the regulations regarding all that will take much much longer because the very fact all this engagement driven software is actual poison for the brain hasn't reached the stage where you can just hammer down facts and drown everyone who still thinks this is a good idea. They should show how all that affects overall productivity and all the billions and trillions they throw out of the window, how it pours oil into the fire of more and more people being overly stressed (which is not just work causing this) etc.

Over the years I was wondering why management is often so bad to begin with. There are terms like "stupid" that are often used -- I certainly did and still do -- but more often than not the people in question are not really stupid. What I came to realize seems obvious in hindsight: They lack the education to do their jobs right. Question really is, if there is any education that even builds the right foundations for that. If I look at something like [1] I get a chill down my spine, in return I managed to finish my buzzword bingo card (again).

[1] https://www.wgu.edu/online-business-degrees/management-leade...

The problem is software, though. I have a X200s with 4 GiB RAM from 2009. It was interesting to see how Firefox got slower and slower over the years. Granted, it not only is Firefox but also retard websites which use loads and loads of JS to display static content in the end. In return, it is not like JS didn't exist back then: The XhtmlRequest thingy for dynamic website updates or whatever the name for that was has been added years prior to that.

So, yes, a lot of this comes down to software and a massive waste of cycles. I remember one bug in Electron/Atom where a blinking cursor caused like 10% CPU load or something along that line. They fixed it, but it tells you way more about how broken the entire software stack was at that time and it didn't get better since then.

I mean, think about this: I used 1280x1024 on a 20" screen back in the mid 90ies on (Unix!) machines that are insanely less powerful than even this X200s. The biggest difference: Now you can move windows around visually, back then you moved the outer frame of it to the new place and then it got redrawn. And the formatting options in browsers are better, i.e. it is easier to design the layout you want. Plus there is no need for palette changes when switching windows anymore ("true color"). The overall productivity hasn't kept up with the increase in computing power, though. Do you think a machine 100x the performance will give you 100x the productivity? With some exceptions, the weak link in the chain were, are, and will always be humans, and if there are delays, we are talking almost always about badly "optimized" software (aka bloat). That was an issue back then already and, unfortunately, it didn't get better.

Germans have this "StVO" which regulates the rules in traffic and also what happens if you not follow them. Crossing a red light can result in a ticket, no matter whether you are a pedestrian or driving a car. Naturally, doing that in a car is a strict no-go, while pedestrians, if there is no car traffic, you will see them ignoring it. Still, they can be fined for doing so regardless whether there was car traffic or not. However, breaking the rules laid out in StVO is not a felony. It can become one if we talk about reckless driving which results in dead people.

Away (enough) from traffic lights, crossing streets is perfectly fine, but you have to watch the traffic. Walking on a street (i.e. not just crossing it) can be considered a "traffic hazard" (if there is any traffic to begin with) and may result in a fine as well. One thing clearly forbidden is crossing an Autobahn by foot which is why there are always bridges or tunnels to cross it, for pedestrians and other traffic alike.

There was a recent article in The Guardian: https://www.theguardian.com/environment/2024/oct/14/nature-c...

Seems like the models have quite a few holes. It made me wonder if anyone has considered making a complete list of assumptions that are baked into these models, so they can be looked at in detail.

I remember looking into Rust for a personal project, on embedded, in 2016. After poking through all of it I decided against doing that because it was clear I'd be spending a lot of time getting Rust working at all instead of doing anything for the project itself. So C it was.

The thing I have to say in the context of the article is this: There is no way to know whether a complete rewrite in C would have yielded similar results to Rust. The phrase "C prototype" made me squirm, even more so when reading that in the context of critical infrastructure. It is known by now (or should be) that such prototypes live on like zombies, so unless it is really some throwaway (from the point of architecture!), these things tend to live on for longer than most feel comfortable with. And, being so critical in function, maintainability is one of the primary concerns.

Yes, Rust will, eventually, at some point, maybe? the go-to language we use in the embedded field, but we are talking not just about a language replacement, we are talking ecosystem replacement. That is not going to happen overnight.

That said, as some mentioned Java, Perl, and such things: I revived a personal Perl 5 project not too long ago that was more than 20 years old by that point. Needed a small change because the latest installment of Perl 5 is a bit more restrictive with some borderline syntax things (good), but other than that it just worked. In the larger context of the project there is also some C code for binary file processing, also >20 years old. Needed a renaming of a POSIX function (arguments and functionality all the same, though), and then it worked, even compiled as native 64 bit code. Granted, there are not that many dependencies beside POSIX, and the code was even back then written to a level of quality that allowed it to run on all sorts of (POSIX) platforms already.

Which is why "C prototype" sounds to me like "we cobbled something together", and all sorts of bugs are no surprise then. You can cut only so many corners before it becomes an issue, especially in software that is used all the time and in a critical place of a system. This needs to be done right, else you will waste a lot of time (and money!) afterwards.

Youtube link from 7 years ago to give some context about the progress and also "flexibility": https://www.youtube.com/watch?v=01y6bR6ETpA

PC speaker:

- 8088 mph demo: https://www.youtube.com/watch?v=yHXx3orN35Y

- Area 5150 demo: https://www.youtube.com/watch?v=fWDxdoRTZPc

- Stormlord (game, 1989): https://www.youtube.com/watch?v=lmDJt1etzRE (unfortunately doesn't keep intro screen around for long)

- A nice video explaining PC speaker with examples (also features Chronos from ZX Spectrum): https://www.youtube.com/watch?v=jD4m9JvLy2Y