Your Web browser is probably the best example. When you visit a Web site, your browser discovers resources and understands how it can interact with them.
It certainly does not. Sure it can crawl links, but the browser doesn't understand the meaning of the pages, nor can it intelligently fill out forms. It is the user that can hopefully divine how to interact with the pages you serve their browser.
Most APIs however are intended to be consumed by another service, not by a human manually interpreting the responses and picking the next action from a set of action links. HATEOS is mostly pointless.
There really should be a legend somewhere, but in practice the amateur astronomy community has standardized on a convention that's more or less the same in color scheme and scale to the one reported here: https://djlorenz.github.io/astronomy/lp2020/colors.html.
You'll see the same scale in use at other light pollution sites, such as:
>Buffer also comes with additional caveats. For instance, Buffer#slice() creates a mutable segment linked to the original Buffer, while Uint8Array#slice() creates an immutable copy, resulting in possible unpredictable behavior. The problem is not the behavior of the Buffer#slice() method, but the fact that Buffer is a subclass of Uint8Array, but changes the behavior of an inherited method.
But this is an implementation detail, not specified behavior. Changing method behavior in subclasses is a key aspect of inheritance.
Completely different behavior is not an implementation detail.
Changing method behavior in subclasses is part of inheritance, but it shouldn't confuse or mislead. In the case of Buffer and Uint8Array, the altered `.slice()` functionality isn't a mere implementation detail; it's a significant deviation. This inconsistency can lead to unexpected bugs, especially for those who assume similar behavior based on the inheritance hierarchy. It's crucial for reliability that such fundamental behaviors remain predictable across subclasses.
Any behavior that is not defined in the spec[0] is, by definition, an implementation detail. Relying on undefined behavior is a recipe for bugs. If you need an immutable array, and the spec doesn't require the returned array to be immutable, you should create one yourself.
Steps 14.g.i to 14.g.ix detail the transfer of data from the original TypedArray (O) to the new TypedArray (A). It involves reading values from the original and writing them to the new array's buffer, effectively duplicating the data segment. The process ensures both arrays are distinct with separate memory spaces.
Being tall gives you an obvious advantage at basketball. As a result many tall people are drawn to pursuing a career in basketball. Could it be that ADHD gives you an advantage at the kind of tasks involved in software engineering, and that many people with ADHD are naturally drawn to this kind of work, even though the advantage is not so obvious as a physical characteristic like height?
If you are coming from a Computer Engineering background or within a IEEE area of influence then SE is used everywhere as an acronym for Software Engineering.
I assume that if you are coming from Computer Science background you are not so caught up on making everyone aware that what you're doing is Engineering, so Software suffices.
This article (and every other article I can find on the ban) conflates whipped cream cans[1] with whipped cream chargers[2], which is what the law[3] bans.
Are these really considered for professional use only in US? Here we use them at home since the result is infinitely better than the instant whipped cream variants.
More or less. My local grocery stores don't carry the device or the cartridges.
Professional or higher end cooking stores might carry them, but the easiest place to get them near me would be a head shop (the places that sell pipes and bongs and what not, if that phrase doesn't internationalize well). Virtually all the head shops near me carry both the device and the cartridge.
