TrueDuality

I know this isn't the spirit you meant it in, but I'm also impressed with humanity that we've managed to develop something as capable as it is (admittedly significantly less reliable and capable than a person) at only an order of magnitude difference in power consumption.

The reference design problem is an issue where a manufacturer like Broadcom creates a specialized chip. To use this chip they create a "reference driver" for it, package it in a custom firmware, then will never update that reference software. I've worked building internet routers for homes and small business and there are pieces of software we couldn't touch because they had been modified and only the fully compiled version is provided.

Broadcom passes the buck by calling it a reference design and washing their hands of it. Some upstreams do provide the source, but it's the complete source, not just the changes they made and usually without any specific reference to what the specific version they based their changes on was. Trying to tease specific changes from the Linux kernel's raw source code is quite the needle in the haystack problem.

I'm not sure how a lot of device manufacturers _could_ handle this. They tend to have very small development teams that are more electrical engineers than software engineers and usually their only directive is to make it work under an extraordinarily tight deadlines. Maybe part of the answer is they need to hire more to be more responsible... But even with experienced developers _every single hardware manufacturer_ is going to have to repeat the security fixes that companies like Broadcom refuse to fix.

I don't even know where to begin proposing a legal foundation for reference design software. I do think if the penalties and pain were strict enough at this level it would lead to a different shortcut that would be much more beneficial to the world... If Broadcom and other companies doing this kind of malicious apathy were forced to keep their reference designs up to date, my money would be that they stop doing it entirely and instead get those driver merged into the Linux kernel proper where it can be properly maintained and updated by the legion of developers that care.

The act of getting that code into the kernel would force them to improve the code and not take the shortcuts that cause so many headaches because the kernel developers gate the quality of code they produce.

The first is Jones Forth (https://github.com/nornagon/jonesforth), start with jonesforth.S and move into jonesforth.f. I really enjoyed following along with it and trying my hand at making my own stack based language.

The other is Xv6, a teaching operating system from MIT (https://pdos.csail.mit.edu/6.828/2021/xv6.html), not all the code or implementations are top notch but it shows you non-optimized versions (just because they're simple and more readable) of different concepts used in OS design.

If you're interested in the embedded world, there is a really neat project I've been following that feels a more structured and safe (as in fault-tolerant) while still staying pretty simple (both conceptually and in the code itself): Hubris and Humility (https://hubris.oxide.computer/).

I don't see any inconsistency in this ruling.

It's been on and off for a long time, mostly quick "this is how I solved this specific issue" posts but I get enough natural traffic it's clearly helping some people. I want to make time for more long form writing though.

* The proposer has clearly not done any research on how to actually collect anonymous data (they'd never heard of differential privacy for example).

* They want a plug and play solution (they specifically say they don't want to do more work than that)

* They are not open to discussing privacy regulations such as GDPR

* They are not willing to bend on the most contentious points of their proposal

* The system they want to use collects invasive metrics that can be de-anonymized and has only been used by a niche distribution

Because the de-anonymization bit might not be clear, let me summarize some of the things that the Endless OS metrics collect:

* Country

* Location based on IP address to within 1 degree lat/long

* Your specific hardware profile

* Daily report that includes your hardware profile, along with the number of times the check ins have occurred in the past

* Detailed program usage (every start / stop)

* An unspecified series of additional metrics that can be sent from anywhere else on the system via a dbus interface

Additional this proposal wants to explicitly collect:

* What packages and versions of such are installed

* Specific application usage metrics (the example they give is the gnome settings panel)

They discard the IP address, but how hard do you think it is to differentiate users based on the combination of hardware profile, +/- 1 degree of location accuracy, their specific set of packages (and knowing the history of package installs/uninstalls already through their package manager). The proposal doesn't meet its stated intentions of being anonymous, and the proposer actively understands that users don't want this but believe their desire for the metrics overrides the end users desire of not being tracked.

It's a black box with no incentive to participate unless you're one of those specific types of users that is dedicated enough to put up with all of that, or users that have never done it before and are trying hard to contribute back.

The conversion between `[]` and `0` is the flaw that is hard to reason about here and propagates through any code that interacts with it in a way that violates a programmers expectations.

I do have a nitpick I think is important. An empty byte array getting converted to zero seems like a bad edge case that should probably produce some kind of error invariant.

This isn't a minor concern if the intent is to use this in serious applications that require this degree of formalism. The two proofs are easy to break: `ToBytes(FromBytes([])) != []`. It's an obvious example of the issue: FromBytes handles inputs ToBytes can't generate therefore they are not true inverses of each other.

It's a simple case but it was quick to find in this simple example, and it hints at dangerous oversights that could lead to severe bugs in more complex scenarios, like in cryptography. It's critical to account for such edge cases.

It's generally really well respected by a lot of software. It's just not well known enough that its annoying. In my experience a lot of the failures are from Apple developers assuming that this is a "Linux spec".

It's very flexible and widely accepted. It's just not accepted _enough_ to be annoying.

As a fediverse host you can probably make custom spam like filters, and I'm sure there will be some distributed tools to fight this kind of thing... But right now a lot of the fediverse is assuming that moderation of external hosts is pretty straight forward and not actively adversarial. If you disagree with the policies or the populace that is attracted to a particular instance block the instance. That doesn't work with something at this scale.

I don't agree with instances proactively blocking Meta before they've shown their true colors, but I also don't think they're wrong. I just think we should let the monsters take off their mask and allow the social consequences to come when the blocks happen for a good reason.

There might be an argument for cost at the highest scale in each field which few in either profession really make it to but I'd bet even then its pretty on par.

I've been a huge fan of comparing the complexity or cost of a profession. We as a species specialize because doing these tasks in the most efficient way requires managing large number of details that are not obvious at first glance.

> "open source" marketed as trumping "open system".

Common use and understanding of the use "open" evolved decades ago.

Your comment also tries to side step the issue at heart people are annoyed and frustrated by. The founding principles of the OpenAI foundation laid out exactly what that usage of "Open" meant for their organization and they have since backtracked on their own principles.

I tested different control schemes and thrust firing plans, added support for different types of thrusters, errors in sensor readings, atmospheric drag depending on altitude, weird anomalies in the earth's magnetic field, simulated bit flip events and hardware lockups (I left the internal watchdog out of the hardware lockups which is probably not realistic).

In an effort to stress test my simulator I ended up writing a genetic algorithm solver for thruster, magneto-torquer, and reaction wheel placement on arbitrary craft bodies with different mission plans and let it solve it.

I ended up designing a physical circuit board matching the simulator, flashing the board with the same code that was running in the simulator and it worked! I roughly made an approximate cube sat (10cm^3) (had a mechanical engineer friend design me a frame and manufacture it for me) with some small cold gas thrusters out of pressurized CO2 cartridges, controlled by solenoids, and placed by my genetic algorithm.

I dropped it off a cliff that was ~600ft high (best I could do for a "zero gravity" environment that was away from people). It was able to completely arrest its angular rotation before slamming into the ground which is better than I was expecting.

It comes down to upgradability for me. The display is going to last far longer than the smart software running on it. Turning on my TV takes a full minute and a half before it will accept inputs from its remote, I've periodically connected it to the internet to check for updates and in two years there hasn't been a single one.

That's not true for every TV but in general my experience has been the built-in Roku, and other smart TV features are poorer quality than the stand alone sticks and either don't get updates at all or significantly less frequently. Because of the nature of these appliances they aren't as disposable so manufacturers have less incentive to provide those updates and high quality experiences as the stand alone products.

All that smart poor quality software on the TV itself compromises the core functionality of the TV itself which is being a good medium for the display of a user's choice content.

This doesn't just apply to software development. There are a lot of garbage jobs, dead end positions, where the people are effectively not doing anything. That is a weight on our economy but we can't just cut them out. What would those people do if they didn't have to waste so much of their time to live? Sure there are going to be people that go all in on becoming puddles on the couch, but I'd argue more people have passions they would actually have the energy to pursue.

People could spend more time with their families without being stressed out and burned out by everything else in the world. I'd argue that would most likely lead to healthier childhoods for kids, likely with better supplemental education as well leading to a smarter society in the long run.

People get tired of partying, and the people that don't make good examples for the next generation of what not to do. You can see that in our current society as the younger generation is drinking significantly less and doing fewer drugs to the point major alcohol manufacturers are concerned about their bottom lines.

There will always be degenerates, but people want the fulfillment that comes with actually doing things like you said. They will find that one way or another.

For systems that I've worked with that have firmware that small or even smaller have had power budgets in the <50mA/hour range... This modem uses up to a full amp at 3.3V (presumably only while transmitting but I'd bet its receive mode still busts that power budget in under a minute).

I can't think of the use cases for these modems that use that little data and have that much of a power draw...

Attempting to look up domains with the intention that they don't exist and are expecting the general case to be a failed query is not using the DNS system as intended. As I mentioned this could be solved by the application including a domain they control so they are not excessively consuming a public good at the expense of others (someone does have to pay for these servers).

The roots should not be expected to double their capacity because one application implements a feature in bad faith.