restalis

"The energy density of batteries is an order of magnitude less than fossil fuels, and you have to carry the heavy batteries with you the entire trip (vs burning off fuel as you fly)."

It's even worse. Nowadays, in order to land, the aircraft needs to be almost empty, otherwise the mechanical structure that supports the stress of impact with the runway may break. So, heavier (as with batteries included) aircraft landing will mean the need to design sturdier landing gear, and stronger landing gear will most likely mean heavier materials as well.

"For jet engines, the only thing that comes to mind is electric aircraft. No single-crystal turbine blades needed at all. I may have picked a bad example, but the principle stands."

I understand the idea you wanted to convey and that commenting on the technical detail is not something we're supposed to do, but the technical side of your example is just too glaring to ignore. A people-carrying aircraft, be it of electric propulsion, or of other type, is heavy. Like, several tons (at minimum) heavy. To acquire the necessary portance, the aircraft has to be accelerated (on its inert wheels) on the runway up to the take-off speed and then to be able to hold the cruising speed, using engines capable of generating such thrust by only moving the air. That's a lot of force right there, and the engine that has to do this, will have to be pretty tough. Regardless of the fact that the source of the on-board energy is electric or not, that same air will have to be moved, somehow, at the needed speeds, and it will be by an engine that will look and work pretty much the same way the current jet engines do, since the shape is dictated by the aerodynamics and the internal design is given by the (air) fluid dynamics it has to work with. The single-crystal turbine blades are just an optimization. Weaker (regular fine-grained casting) materials can be used, but that will mean limiting the performance to lower tolerance levels (and most likely be heavier as well, to compensate for the lower mechanical strength).

Your range checking requirement is just one of many things that may or may not be necessary to someone using this. Taking them all into account (besides the fact that may be unfeasible, if there happen to be some conflicting requirements) would render the solution to be unnecessarily complex. It's better to focus on the minimal set of viable requirements and thus have a base design as simple as possible. For additional requirements, just go and complicate your design (and be the only one having to pay the costs that come out of that complication), hopefully only when and only for as long it makes sense to do so. For the need you mention, some kind of container wrapper may do, with the amount of number's words specified in it. A good thing is that you'd be able to limit the use of such container-wrapped numbers only to some situations (like the exchange of data to and from unsanitized areas).

While there are indeed "details" out there that have a great impact on the macro-dynamic, and even pose as blockers, history also provides us many counter-examples. The steel-making process has been invented and reinvented many times and in different places in an (arguably) independent manner. The same for sea-faring, writing systems, laws, and so on. They have all been different but did enabled progress more or less in similar way, and thus - are also details that it's fair to gloss over.

You two debated this as a philosophical or even moral issue, but it changes everything when you look at it from the natural hazard prospective. It doesn't even have to be a subjective matter. Picture this - you know the climate change is happening and you understand that some colony of animals will surely vanish because of that if you wont do a thing about it. Doing something could mean just taking a few pair of animals and relocate them to a safer area. Do you think that the survival of such descending colony of animals mean anything (to anyone)? Who can argue that it won't be our time (and obligation) to reduce the risk of having the only known capable civilization residing on only one planet or galaxy?

The dilemma of spending significant amount of effort and resources for a colonizing project when the result won't benefit the enterprising society is not new. When looking for a reason, considering only the (individuals' or collective's) benefits on a rational basis does not make much sense indeed. Most likely there must be something more, akin to a religious goal, aiming for species' or civilization's greater good.

It's also called "vision". It's what provides and powers directions on large and long term scales. Those "simple" and "mundane step-by-step issues" are just chores by themselves, yet at the same time may become stepping stones in the context of a well thought vision that people buy into and rally behind.

In the open space, shades get very cold, like a few degrees over absolute zero cold, because even without a medium to facilitate convection and (atmospheric contact) conduction, the loss of heat through mere radiation (into the pitch black universe) is very efficient (for normal, non-reflective materials). Thus, for an astral body to remain in a melted state, continuous steams of energy should be poured in (and some thermo-insulating gaseous atmosphere may also help to reduce cooling, if the body in question would have enough gravity to retain it), but that's hardly a thing to worry for a project where the energy itself is carefully controlled and dosed.

"to Thai, squid, octopus, and cuttlefish are all ปลาหมึก. For English speakers, those are similar things, but all clearly distinct. But for Thai speakers, they're all ปลาหมึก, just different types."

Then, ปลาหมึก = coleoidea? If so, the squid, octopus, and cuttlefish are (in English and many other languages) all just types of coleoidea: https://en.wikipedia.org/wiki/Coleoidea

Also, the kind of satellites that aren't much more than mirrors, even with today's knowledge, they can be designed to change their profile/surface and thus reduce the absorption of the incident radiation, if they'd had to cross the space between the sun and the sunlight collector areas.

"I’ve seen too many «well crafted» implementations of such technically vexing features as «fetching data and returning it» that were so overengineered that it should have been considered theft of company money."

This judgement has merit. However, over the years I got to perceive that over-engineering tendency to be the manifestation of exploratory spirit in one's craft. This is how the Unix got to be created at Bell Labs. To their managers, Ken Thompson and Dennis Ritchie worked on programs like the "ed" editor, thus they cared about "value being provided to the user (or the business)". What was later officially named Unix was not pitched as an operating system, but instead framed mostly just a needed way to organize the growing set of utilities, among other things (i.e. as a footnote). What are the over-engineered bits (and the related gained experience) in a given project may become useful for something else. People (tend to) do this kind of stuff. But should they be blamed, considering the enticing promise of growth and development of new technologies, practiced by employers themselves, as part of recruitment game?

"We should look at how people are using LLMs right now instead of chasing promises of superintelligence."

This. When more computing power and memory resources became available to software engineers, we've seen how that impacted the software development. Sure, there were happy stories of new class of problems being attacked, which couldn't before due to resource limits, but a lot of software just stopped being frugal and did pretty much what it did before, but somehow consuming much more. Extrapolating to the case of staggering resources poured over the AI solutions, I'd be surprised if most of it won't just be consumed to generate higher resolution (and longer) videos.

rsync does what was designed to do and the lack of scope creep is not a bad thing. There is "fpsync" - another tool on top of rsync (which was mentioned in one of the comments at article's page) that covers the parallel processing use-case: https://manpages.debian.org/bullseye/fpart/fpsync.1.en.html

"No stuffing about with swapping physical hardware just because I've temporarily relocated myself."

That's exactly the use case for which the carriers offer roaming plans. The bonus is that you (as in your phone number) get to remain connected and accessible by your contacts, as no other phone number is involved at any point. One should not need to change the SIM unless is about one's phone change.

Managing the light source, specifically the 13.5nm length on the wave spectrum, that gets generated from overheated tin plasma, is in fact the most challenging part of the machine. Here "managing" includes the process of hitting a rightly sized tin droplet with lasers at the right angles, and all the rest of the complicated fluid math necessary to get the most of that precious lighting moment, as well as the proper handling of that spark event's after-effects, of course. As opposed to the rest of the machine parts (like directing the EUV light to the reticle through those mirrors you mention), the light generation part is dynamic, very easily to get wrong, and very costly to iterate on.

I was thinking about this too. When you read a program, there is this information payload, which is the metaphorical ball you have to keep your eyes on, and more or less forget about the rest as soon as it isn't relevant any more. In the functional paradigm it's like seeing the juggle of a bunch of such balls instead (plus the expectation to admire it), but that's just wasteful on reader's attention.

Most likely, it didn't happen (yet) due to kernel related stuff being still actively worked on¹ and (more importantly) due to a shortage of developers willing and capable to tackle that kind of challenge.

¹ At the time of this writing, there are open PRs like this one: https://github.com/reactos/reactos/pull/8422

"putting yourself and your hard work in legal risk"

Like what? I'm genuinely curious what personal risks faces anyone from contributing to ReactOS. I also am curious what kind of legal risk may threaten the work? I mean, even in the unlikely scenario that something gets proven illegal and ordered to be dismissed from the project, what would prevent any such particular expunged part to be re-implemented by some paid contractor (now under legally indisputable circumstances), thus rendering the initial effort (of legal action) moot?

"A good example I think has adjusted the behavior of the ecosystem is Rust: it makes certain things much easier than before and slowly the complex bug-mired world of software is improving just a little bit because of it."

From a software design prospective, the functionality that should go into a compiler is code compilation only. Taken it to extreme (as in Unix philosophy), if the code compiles, then the compiler should just build you the binary or fail silently otherwise. The code checking and reporting various aspects of the quality of the code is supposed to be a static code analyzer's job. (In reality, pretty much all compilers we have are doing compilation coupled with some amount of lighter code checking before that, and the static code analyzers left only with the heavier and more exhaustive code checking.) What Rust does is to demand its compiler to perform even more of what a static analyzer is supposed to do. It's a mishmash of two things (which still manage to stay separate things when it's about other programming languages, because that makes sense) and masquerades that as revolution.

So, (even when it's about code in blamed languages like C & C++) the "the complex bug-mired world of software is improving just a little bit" by not skipping the static analyzer kind of expensive checks, the kind that Rust happen to make impossible to skip.

The transition from kilobytes to megabytes is not comparable to the transition from megabytes to gigabytes at all. Back in the kilobytes days, when the engineers (still) had to manage bits and resort to all kind of tricks to somehow make it to something working, a lot of software (and software engineering) aspects left to be desired. Way too many efforts were poured not so much into putting the things together for the business logic as were poured into overcoming the shortcomings of limited memory (and other computing) resource availability. Legitimate requirements for software had to be butchered like Procrustes' victims, so that the software could have a chance to be. The megabytes era accommodated all but high end media software, without having to compromise on their internal build-up. It was the time when things could be properly done, no excuses.

Nowadays' disregard for computing resource consumption is simply the result of said resources getting too cheap to be properly valued and a trend of taking their continued increase for granted. There's simply little to no addition in today's software functionality that couldn't do without the gigabytes levels of memory consumption.

This fits your description: https://en.wikipedia.org/wiki/Variable-length_quantity

This tendency of requirement overloading, for what can otherwise be a simple solution for a simple problem, is the bane of engineering. In this case, if security is important, it can be addressed separately, e.g. for the underlying text treated as an abstract information block that has to be packaged with corresponding error codes then checked for integrity before consumption. The UTF-8 encoding/decoding process itself doesn't necessarily have to answer the security concerns. Please let the solutions be simple, whenever they can be.

Whereas it may be used in outdoors-like natural lighting, it is not (always) true that it is "usable in the sun". On one such product¹ there's this "Important Notice" advising users to "avoid exposing the E-ink screen to direct sunlight or intense ultraviolet rays, as this may cause irreversible damage to the screen."

¹ https://shop.dasung.com/products/dasung-25-3-e-ink-monitor-p...

The world is dependent on plastic by now, and needs a lot of it. The negative stigma it got lately is due to playing fast and loose with it in the past, but it is a necessary class of materials, and having sustainable means of mass producing it is a good thing.

The main benefit for me with this approach is that the boundries are not transparent anymore. That content printing is such a boundry. Your data is about to exit through there and you're summoned to handle that. The inconvenience that comes with it is as any other when security enters the play. The same with the data management responsibilities - who handles what, for how long, and with whom. Without data type distinctions everything is (more or less) common, with vague or broadly defined ownership.

"Isn't 10-15% faster compression, and 5-10% faster decompression, a very nice «feature»?"

Although much code can be optimized to get it to run 10-15% faster, if that comes at the expense of legibility then such "feature" get rejected nowadays. Translating an existing codebase into a language that makes things more difficult¹ and (because of that) has (and most likely will have) fewer engineers willing to working in it looks very much akin to applying legibility-affecting optimizations to me.

¹ ...and not only. I've already described in other comments some of the issues I see with it as a software development tool, here https://news.ycombinator.com/item?id=31565024 here https://news.ycombinator.com/item?id=33390634 and here https://news.ycombinator.com/item?id=42241516

"It's a leaked copy of the Windows source code from a long time ago that has been hacked on."

That's a claim that... at best it seems that hasn't yet gathered behind it enough motivation to clarify anything, and at worst is just a plain malicious FUD. It doesn't even matter, when you think about it. Even if we'd assume a legal accusation of leaked-resembling code in all that pile of modules, all that ReactOS team needs to do is to formally contract reimplementations by independent teams for any of those allegedly guilty modules. In this light, such an accusation is very unlikely to happen, and probably there won't be even a half-baked effort to officially demand clarifying and putting any potential issues to rest. So, about those people out there with an interest in painting ReactOS as plagued by leaked code, entertaining this uncertainty is all they'll do, nothing more.

"You can look up the «history» of it and how it has symbol names for companies with whom Microsoft worked to solve specific application issues."

I assume you aren't going yourself to provide a reference to what you're alluding to in that public repository?

It would be annoying. If the use-case is as a portable application, but the application would want to let the user know (in a sufficiently loud manner) that it can install itself, then either the user would be forced to pay attention at that aspect every time it opens the application, or that "portable" application will have to somehow pollute the environment with (at least) a note for itself of the fact that user was offered but chose not to install anything. That note is usually just a first change in the system and, for a non trivial application, is way too easily followed by many other kind of saved changes, which in itself looks like a creeping install. Then, if the user would actually choose to install, the app will have to do what, make shortcuts to its current location, which may be a thumb-drive, or another less ideal placement for a program (because how many of us take time to think about file management anyway)? Or, if the application makes a copy of itself to a conventional place (for an application) in the system, then now the useless standalone executable either gets forgotten about or becomes a burden for the user (who has to decide what to do with it).

The most appropriate behavior for a portable application is for it to stay clean by default and only offer the user to explicitly enable persistency-dependent functionality. When the application starts, it checks if there's any previous trace of itself and depending on that it either keeps its portable-like clean behavior or switches to installed-like one.

For people comparing this to existing solutions: this is an open-source work, ready for anyone with chip production capability, with no product licensing involved or due royalties to be paid. And, given chip's simplicity, the production capability needs are not that high. Existing chip manufacturers may provide a good and convenient ready available solutions, but that's just a different thing (with you merely as a chip manufacturer's client). This is the vertical integration option, if you need it.

This doesn't make sense. I, for one (transitioning to Linux usage only gradually), haven't been aware of the systemd and its criticism, and I'm grateful for the info. Then, the informed users can vote with their feet. Things change all the time, and only mass adoption/usage is what makes a given distribution to be mainstream or niche.

So, please do continue to criticize, continue to raise awareness. That's useful.