Saunas (at least the way we enjoy them here in Finland) can be pretty humid, because we throw water on the stones of the stove. But throwing too much water can make it intolerable, and lethal if you don't follow your instinct to leave if it gets too hot.
Normally in a sauna it's not constantly so humid that sweating wouldn't be able to keep your body temperature normal (as long as you stay hydrated). Throwing water on the stove raises the humidity just momentarily and makes you sweat at full capacity, but normally you would wait for some minutes before throwing more water.
If air is humid enough, sweating can't cool the body anymore because sweat won't evaporate, so already 35C is lethal in 100% humidity.
Your strategy is not optimal. If you want to be efficiently freeloading, you should not be announcing your position.
Freeloading with vaccination only works if just a small enough minority of people are doing it. In order to minimize your personal risk from both covid and potential side effects of vaccination, you should be advocating for others to get vaccinated but not get the shot yourself.
If you publicly announce that you are not going to get the vaccination, that may encourage others to avoid it as well. That's against your own interests, because then it's more likely that you get covid when the vaccination coverage in the population is lower.
I used to be heavily involved in the demoscene during late 80's/early 90's. (And still occasionally visit demoparties.) I think the best thing in making demos was the feeling of achievement when you managed to get a new effect working. Of course it was a bonus if this was something never seen before, or broke some record, or even placed well in a democompo, but the feeling of "I can do this" was the main driving force behind it all for me.
Recently I've got similar feeling of achievement in DIY electronics. Back in the day making PCBs was difficult and information on how to design them was hard to find. My best attempt was an audio digitizer based on instructions from a magazine, and I never got it working because my hand-drawn PCB was so bad.
These days one can design PCBs with open-source tools and get them manufactured professionally for very cheap. There is a wealth of various microcontroller modules and add-on boards that can be used as building blocks in projects. Internet is full of design resources, and all possible components one can imagine can be ordered online.
Although I haven't participated in any IRL meetings, I think there's also something similar to demoscene in these communities, both online and IRL. It's not as competitive as demoscene used to be though (but I think that's only a good thing).
Most of these DIY electronics projects would never be possible in commercial setting because there's no viable economy behind them. However, as it's relatively cheap these days to implement even fairly complex electronics projects, we are seeing stuff that's somewhere in this intersection of non-commercial / creative / cutting edge technology - just like the demoscene used to be.
This is not about peak sensitivities. The RGB colors are used as primaries because they provide a large response on one type of cones, and as small as possible response on the two other types of cones.
Blue is chosen to have as small wavelength as possible (S=small) and red is chosen to have as long wavelength as possible (L=long), while both being still in the visible spectrum with large enough response from S and L cones respectively.
Since M and L response profiles overlap anyway and just the ratio of the response changes, green is chosen to be as far away from the red, but still outside of the response curve of S cones that get stimulated by blue. This happens to be also around the peak sensitivity for the M cones.
CMY/RGB is not an arbitrary choice for color model. It's the best approximation for stimulating the color receptors in the human eye. RYB on the other hand is just historical model that still exists because traditions in the art teaching change slowly.
It's a wrong notion of primary colors that one could choose any three colors for primaries. Yes, it's possible to choose any three colors and mix a set of other colors within the triangle defined by these three. However, by definition a primary color is a color that can't be mixed from any other colors. Cyan, magenta and yellow are such colors. It's not possible to mix cyan or magenta from the RYB palette, on the other hand red can be mixed from magenta and yellow, and blue can be mixed from cyan and magenta.
The reason why RGB/CMY are the primaries is exactly because of the stimulus response of the human eye. The purpose of color reproduction is to cause a specific response in the three receptors in the eye. Since there are only three different kinds of receptors, it's possible to produce the exact same response in the receptors in multiple ways (thus we have metamerism). RGB primaries are chosen because each of the primary colors causes a large response in one type of receptors and as small response as possible on the other two receptors. (And CMY is then the opposite of this by causing as large response as possible on two receptors, and as small as possible on one.)
The reason why the traditional RYB palette has two versions of each of its "primaries" is because RYB "primaries" are so bad at covering the visible color gamut that by introducing two versions of each color it's possible to expand the triangle from which to mix into a hexagon.
The exact wavelength profiles for R, G and B may vary between different display technologies, and some technologies can represent the color better than others. This doesn't mean that the RGB model is arbitrary in any way, but that there are just practical reasons why the theoretical optimum is not always reachable. Some of the standards for RGB reproduction take this into account and define a color space that follows the common technologies rather than the theoretical optimum, and thus have a limited gamut.
Color printers with more than 4 inks don't abandon CMYK model. I have a large-format printer that in addition to basic CMYK has gray, light cyan, light magenta and light yellow inks. The purpose of these lighter shades is to allow printing light areas with less visible dot raster. The color model is still CMYK.
Some printers also include red, green and blue. These exist basically for the same reason there's black in CMYK. Even if CMY is theoretically correct model for wavelength response to match the human eye, there are real-world limits to ink and paper technology; for instance 100% fill of all CMY is not as black as 100% fill of black.
Purpose of spot colors is not related to color model, but color reproduction. If you define your spot colors by Pantone number, there's a guarantee that the color will match exactly what you ordered. It's much harder to get exact color reproduction with CMYK process, because the number of variables affecting the end result is so high. Another purpose for spot colors is all kinds of specialty inks like metallic colors etc. Sometimes it's also a cost issue, because it can be cheaper to use black + one accent spot color than a full CMYK process, or a quality issue, because with spot colors you don't get the color raster.
Now that the Atari ST part of the article is out as well, I'll add some corrections regarding ST graphics format. The article states that "There are no bitplanes here like on the Amiga we saw in the previous entry." This is slightly inaccurate. ST does have bitplanes, but the organization is interleaved to 16 bit words, unlike on Amiga where the bitplanes are stored as separate memory regions.
So in 1 bpp hires mode, there's just a single bitplane (and the memory layout is identical when comparing to Amiga 640x400 interlaced hi-res 1 bpp screen mode). In 2 bpp medium res (640x200, 4 colors), there are two bitplanes, alternating bitplanes for every 16-bit word. So 16 bits of bitplane 0 for the first word, then 16 bits of bitplane 1 for the second word (these together form the first 16 pixels), and so on. In the 320x200 low res mode there are four bitplanes interleaved in the same way.
What this means from the programmer's perspective is that you can do similar bitplane tricks as with Amiga, e.g. modify just one of the bitplanes independent of the others. For instance effects where car headlights change the background image colors can be done the same way on both machines: render to just one bitplane and use the palette to achieve the change in colors.
However, when with Amiga it's trivial to modify bitplane pointers independent of each other to scroll graphics around, on Atari ST all bitplanes are tied to the same base pointer (because they are interleaved in the memory). (And to make things like full-screen scrolling even more difficult, this base pointer is aligned to 256 bytes, i.e. the low byte of the video memory base address is always 0 on Atari ST - on STE this is programmable.)
There are some cases where the interleaved bitplane format gives benefits: while neither of the machines are good for writing texture mappers (or other effects that require manipulation of single pixels), it's slightly more efficient on Atari ST because the layout allows some tricks (e.g. using MOVEP instruction to write 8 pixels to all 4 bitplanes at once from a single 32-bit register).
From the point of view of a game like Another World, the bitplane arrangement of Atari ST doesn't really cause additional problems when comparing to the Amiga. The issue is the lack of blitter (and STE blitter isn't that great improvement, it doesn't have the line drawing capabilities of Amiga blitter and has less flexible src/dst mechanism, so no wonder it isn't utilized by the game).
Typically you'll see a "wave" of blinking emergency lights arriving well before the sudden congestion, you pass that on for those behind you, and prepare to slow down.
I think the intuition gap comes from the misleading arts education about colour. It's still common to teach in schools that primary colors for paint are blue, red and yellow - when the correct primary colors are cyan, magenta and yellow as everybody familiar with CMYK printing can tell. If you search the internet about mixing paints, almost every site claims that the primary colours are blue, red and yellow... So I don't think it's the subtractive mixing itself, but subtractive mixing with CMY colors (and not the wrong model of red, blue and yellow they are used to).
There's long history of arts education with this misconception, partly because suitable pigments for CMY colour model are relatively new invention. Blue, red and yellow also kind of work well enough, especially if you tweak the palette by having two shades of each as your "primary colors". (E.g. you can mix saturated green from cadmium yellow and prussian blue, but if you mix chrome yellow and ultramarine blue, the green will be muddy). It's kind of like instead of having a full triangular gamut of CMY space, you crop the corners off of the triangle and have a a sort of hexagonal gamut.
As primary colors are by definition "colors that can't be mixed from other colors", it's strange that in arts education they still claim that red and blue are primary colors, when it's obvious that red can be mixed from magenta and yellow, and blue can be mixed from cyan and magenta, as every colour printer is doing it like this.
I suppose you don't live in Finland, because I've never heard opinions like that from a fellow Finn.
Last night the outdoor temperature here was -20 C (-4 F). In conditions like this, it's basic human behaviour to give shelter to those in need. I gladly pay taxes so that the government can solve the problem in the most efficient way for the society. It would be much more expensive to let the ER and health care system handle these people when they get severely frostbitten outside.
I'm from Finland, and I think the fine system here works well. There are some crucial differences from the US system however.
First, fines don't go to the local police departments, and local municipalities don't get any financial incentive from issuing more fines. Everything goes to the state, and amount of collected fines is not related to the budgets of the police departments. This means that there are no interests for collecting more fines from any specific demographic.
Second, there are actually two levels of fines. For minor offences (like minor speeding, jaywalking, running a traffic light slightly late) you only get fixed fine. If the offence is serious enough to go to the court, then you may get day fines that are based on the income.
Also, the most extreme fines reported from Finland usually result from cases where someone has cashed nicely from selling a company or something, and because the initial amount of the fine is just based on tax information of the previous year, this may be a very high amount. In reality these fines always become lower in the court. The fines should be based on the current income by the law, and if the defendant can prove that the previous year was just an anomaly and the current income is actually lower, the amount of the fine will be reduced.
I know some wealthy people with very nice cars. They are extra careful to never speed beyond the "safe limit" because it would hurt too much if they got a fine, and instead take their cars to closed race tracks if they want to drive fast. Most people who I see speeding on the roads drive some lower-end cars like BMWs or Audis. I take their speeding as a sign that they probably have barely enough income to afford a car like that and want to show off, because if their income was actually high, they'd be more wary of the financial consequences.
I think it's important to know when a theoretical framework can be applied to the full extent and when the real-life situation is actually a subset that behaves differently.
In this case the problem is solvable within the subset presented by the JavaScript language, but there are other cases where applying theory directly to real life constructs without considering the differences can lead to buggy code. For instance floating point numbers come to mind immediately.
I agree that discussions like this are sidetracking the whole point of a good article, but in order to avoid that, I'd use pseudo-code instead of a real language for presenting concepts like this.
Late to the party, but the proof requires integers with infinite amount of bits. With real-life programming languages there's limited number of bits in integers, and this means that the proof doesn't work with any real-life language such as Javascript.
Consider just 2-bit integers (because it makes this easy, in real life the number of bits is of course larger). If i in F(i) has just 2 bits (possible values thus are 0,1,2,3), each Fn(i) can be represented by a table of four 0/1 values. The function just returns the value at the table in the input index. This also means that there are only 16 possible functions Fn() for a 2-bit input (as return values 0 and 1 can be combined in 16 ways in the 4-entry table). There may be infinite amount of lexically different functions, but based on what the functions actually do, most of them are duplicates that provide the same functionality.
All possible functions with 2-bit input value, and their respective 1-bit return values can be written out to a table:
input: 0 1 2 3
result:
f0: 0 0 0 0
f1: 1 0 0 0
f2: 0 1 0 0
f3: 1 1 0 0
f4: 0 0 1 0
f5: 1 0 1 0
f6: 0 1 1 0
f7: 1 1 1 0
f8: 0 0 0 1
f9: 1 0 0 1
f10: 0 1 0 1
f11: 1 1 0 1
f12: 0 0 1 1
f13: 1 0 1 1
f14: 0 1 1 1
f15: 1 1 1 1
The point is that even if a function is defined by a completely different algorithm (and thus lexically different), it can be reduced to a table lookup, where the size of the table is defined by the number of bits in the input. For instance from the functions above, isOdd() is the same as f10() and isPrime() is the same as f12().
Now, if we take any function above, we can find another function in the table that provides correct answers for 1 - Fn(i). For instance for f12() we have results 0 0 1 1, so we need a function that provides results 1 1 0 0. This is f3(). This is clearly a function that is already in the set.
If there are more bits than 2 available for i, the amount of different functions just grows, but is still limited in the same way as with a 2-bit input. So in order for the proof to work, input variables need to have infinite number of bits.
https://en.wikipedia.org/wiki/Molotov%E2%80%93Ribbentrop_Pac...