Also if say you have image/animation/audio/video link without extension (e.g.: .jpg), you can fool Lemmy using a fragment identifier at the end of URL #.jpg which would usually be used to jump to the fragment id in document. e.g.: https://example.org/image#.jpg
Images in comments don’t get cached, so absolutely yes. But I mean, public IP + User Agent is like minimum of information anyway. Any website you visit gets it.
What is the perceived problem, then? 99% of sites these days are all built with kits that support Firefox just as well as Chromium, the dev choice to not support or intentionally lock out Firefox is either just laziness (not wanting to deal with any potential problems or not given enough time to run full Firefox user tests) or incentive driven (middle manager has word from high manager that they can’t support firefox because highest manager makes bank from Chromium).
The technical limitation isn’t actually there in the modern web, it’s almost always a manufactured limitation. I think I’ve only ever encountered a single website that didn’t actually technically work on Firefox, and that was Weather Underground. Which they ended up fixing after 3 months or so.
Doesn’t that sound like a good description of a problem?
I think I’ve only ever encountered a single website that didn’t actually technically work on Firefox[…]
There’s gonna be a hell of a lot more of them, buddy. You’re gonna have to hang your cat on your balcony to get an estimate of future weather if you want to avoid using one of them how-are-these-even browsers.
Imagine yourself as a homosexual man in Iran (should be easy). Would you say that hiding that big part of you from everyone and even go as far as marrying a woman you don’t even like just not to arouse suspicion makes the problem disappear? Just the fact that you need to spoof your useragent to view a shitty website, the developer of which would (should) die under a car one day 🤞, is a solid proof that you will soon be that homosexual man in Iran.
My SO just had something similar pop up yesterday. She was running into weird errors on her Chromebook, so I had her change her user agent to Chrome on Windows. Everything magically worked. Hmm…
One of these days, someone is going to invent a confluence alternative that only supports markdown and doesn’t have nay of confluences stupidity and it is going to EXPLODE and bankrupt Atlassian.
Computers are binary, yeah? So we have to represent fractional numbers with binary, too.
In decimal, numbers past the decimal point are 10^-1, 10^-2, … etc. In binary, they’re 2^-1, 2^-2, …
2^-1 is one half, so 0.1 in binary is 0.5 in decimal. 2^-2 is one quarter. 0.11 in binary is 0.75 in decimal. And of course you’ve got 0.01 = 0.25
The problem comes when representing decimal numbers that don’t have neat binary representations. For instance, 0.1 in decimal is actually a repeating binary number: 0.0001100110011…
My ELI5 is this. Pretend you have a robotic pizza cutter, but the only thing it can do with a pizza or pizza slice is cut it in half. If you ask for a tenth of a pizza, well it can give you an 1/8 or a 1/16 by repeatedly cutting a slice.
It can also cut you a 1/16 slice, make 1/32, 1/256, 1/512 and 1/2048 slices separately, shift them together for you and be like: “There. Here’s 0.100098 of a pizza. You happy?”
(You can also think of it as the robot cutting the pizza into 2048 slices and mushing together 205 of them to make your “tenth”).
Sure I can try to connect the metaphors, in a binary number system you have numbers 1 or 0 to pick from. How it applies in this scenario is that you can only have up to one slice of each size. That works because if you want two of it, you would instead replace it with a one size bigger slice that is equivalent to 2x the smaller size.
For a general understanding of floating point I suggest you learn binary first and separately, because at the end of the day it’s just another way to write base-10 numbers. Floating point representation is useful because the basic principle is you pick some fraction that is so small relative to what you’re measuring, so you can do most math accurately. (e.g. If I say this dwarf planet is the size of our moon and a 20 tennis balls, the tennis balls don’t really change your idea of how big it is)
At the end of the day, FP is like scientific notation but with like 10 significant digits.
I was recalling a project in perl, which doesn’t have a variety of types. If you add values, you get a scalar, which will be a float if the numbers are not integers.
I am aware my statement isn’t true in several languages
I just recalled, in that project I did have to divide money, which would leave fractional cents
It was a budgeting program, I could put rogue cents where I liked. I think my solution made accounts due $12.553333333… (internally 1255.3333…) each pay period get 12.54, so after n/3 pay periods they’d be 2n cents over. I could deal with that imprecision.
Some programming languages use different rounding method. Might bite you in the ass if you’re not aware of it and using multiple programming language in your application to handle different areas.
You’re telling me there’s someone that has more than 20 million dollars? /s
If you’re handling people’s money you should probably be using arbitrary-precision arithmetic. I mean, you might get away with a long int, but finance is serious business and the amount of data you’re going to be processing relative to your funding is probably going to be small.
Not the project I was thinking about above, but at work my team delivered software handling 13 digit numbers, but that’s in COBOL which does fine with money
People think floats are too magical. Calling it an approximation is sort of leaning into this. Floats have limited precision like every other fixed size representation of a number.
This is sort of saying that integers are an approximation because int(1.6) + int(2.6) = 5. What do you mean‽ Clearly 1.6 + 2.6 = 4.2 ~= 4!
Floating points can’t perfectly represent 0.1 or 0.2 much like integers can’t represent 1.6. So it is rounded to the nearest representable value. The addition is then performed perfectly accurately using these values and the result is the rounded to the nearest representable value. (Much like integers division is “rounded”). That result happens to not be equal to the nearest representable value to 0.3.
It is definitely a bit surprising. And yes, because of rounding it is technically approximate. But the way people talk about floating point makes it sound like it is some nebulous thing that gives a different result every time or just sort of does the correct thing.
I think specifically, they have amazing precision. But the boundaries just don't fall perfectly on round numbers we humans would expect. That's what gets people confused.
Rounding can resolve these problems, or don't use float if you don't need to.
The difference is that when you input a specific, precise floating point number, the number that’s stored isn’t what you entered.
When you enter integers and store them in ints, as long as the number is small enough, what’s stored is exactly what you entered.
If you tell your program that the radius of the circle is 0.2 units exactly, it says OK and stores 0.200000000000000011102230246251565404236316680908203125.
Of course everybody knows that there’s a limit to how many digits get stored. If you tried to store Pi, there’s obviously some point where it would have to be cut off. But, in life we’re used to cutting things off at a certain power of 10. When we say Pi is 3.14 the numbers after the 4 are all zero. If we choose 3.14159 instead, it’s the numbers after the 9 that are zero. If we represent these as fractions one is 314/100 the other is 314159/100000. The denominator is always a power of 10.
Since computers are base 2, their denominator is always a power of 2, so there’s a mismatch between the rounded-off numbers we use and the rounded-off numbers the computer uses.
programmer_humor
Hot
This magazine is from a federated server and may be incomplete. Browse more on the original instance.