30,955 karma · joined September 22, 2009
- I already bought that recently, why would I need another one?
- I already decided which variety of thing you're showing me I will buy, this ad isn't helpful to me.
- Why are you spying on me? That's creepy, I'm not going to click that ad even if it was exactly the thing I wanted to buy right now.
I expect that this experience isn't extraordinarily unique. Having less targeted ads is actually somewhat helpful because it maintains the pretense that ad companies aren't spying on you constantly.
"Brexit" is possible, but it would be in all cases disastrous for Britain. This is obvious. But Brexiters don't want a real-world Brexit they want a fantasy land Brexit where they have every single benefit of being part of Europe and the EU but they want to be able to ignore any obligations "imposed" upon them by that very advantageous relationship. This is, of course, a childish and unreasonable position, nevertheless a great many people were convinced that it was really quite reasonable or that at least that voting for Brexit was a show of solidarity representing British Independence and Strength and yadda yadda yadda, etc. Unfortunately for them, a majority of voters were fooled into voting for Brexit, causing it to pass out of the fantasy realm where it was a meaningless signal of political beliefs into the realm of reality where it will be an unmitigated clusterfuck of epic proportions if it is carried off. Indeed, I suspect if a second referendum were held the following week after the Brexit vote, with the restriction that only those who voted in the first could vote in the second, it would have gone down in flames.
The complication here is that the current party in power, Theresa May's coalition, has a very tenuous hold on that power. They know that if there are new elections they are out. And May knows that if she doesn't kowtow to the Brexiter minority in parliament then her coalition will crash and burn. So she's trying to hold onto power (until 2022) by going through the motions and doing the best she can without any possible clue how to actually get through this mess.
Which comes back to the core problem again. The majority (now) do not want a Brexit. While the Brexiters want "Brexit, but good for Britain" which is an impossibility.
We are basically just children refusing to accept even the most basic levels of responsibility and stewardship for the world we live in.
Ultimately, hawking radiation does not come from within the event horizon, so it can escape into the wider universe.
The "cost" of production of medical technologies has very little to do with their price, in the US anyway.
The appropriate default is, I would argue, the one which preserves the mathematically correct answer (as close as possible) in the majority of cases and enables coders to override the default behavior if they want to specify the exact underlying numerical representation they desire (instead of it being automatic). That goes along with the "principle of least surprise" which is always a good de facto starting point for any human/computer interaction.
Consider a similar example, pointers. Some languages (like C and C++) use pointers heavily and it's expected that devs using those languages will be experienced with them. However, pointers are very "sharp" tools and have to be used exceedingly carefully to avoid creating programs with major defects (crashes, memory leaks, vulnerabilities, etc.) They are so hard to get right that even software written by the best coders in the world commonly has major defects in it related to pointer use. This problem is so troubling to some that there are many languages (java, javascript, python, C#, rust, etc.) which have been designed to avoid a lot of the most difficult to use aspects of languages like C and C++, they use garbage collection for memory management, they discourage you from using pointers directly, and so on. However, even those languages do very little to protect the user from blundering into a mindfield of floating point math.
Consider, for example, simply this statement:
x = 9999999999999999.0
Seems rather straightforward, right? But it's not, it's a lie. Because in many languages the value of x won't be as above, it'll be (to one decimal digit precision) 10000000000000000.0 instead. Whereas the value of ....98.0 is the same as the double precision float representation to one decimal digit precision (thus the difference between the two comes out as 2.0 instead of 1.0). Now, maybe in a "the handle is also a knife" language like C this is fine, but we have so many languages which go to such extremes everywhere else to protect the user from hurting themselves except when it comes to floating point math. And here's a perfect case where the compiler, runtime, or IDE could toss an error or a warning. Here you have a perfect example of trying to tell the language something you want which it can't do for you in the way you've written, that sounds like an error to me. The string representation of this number implies that you want a precision of at least the 1's place in the decimal representation, and possibly down to tenths. If that's not possible, then it would be helpful for the toolchain you're using for development to tell you that's impossible as close to you doing it as possible, so that you know what's actually going on under the hood and the limitations involved.
Something which would also drive developers towards actually learning the limitations of floating point numbers closer to when they start using them in potentially dangerous ways than instead of having to learn by fumbling around and finding all the sharp edges in the dark. The sharp edges are known already, tools should help you find and avoid them not help new developers run into them again and again.
Nuclear waste is comparatively easy to handle. A single country is capable of handling its own nuclear waste and keeping it safe (as France does, for example). The same is not true of CO2 emissions and global climate, which require transnational concerted effort to manage.
2. Check your mirrors routinely (though not constantly, that can be distracting in itself). Stuff doesn't just sneak up on you out of nowhere, unless you aren't paying attention. Cars can't materialize in your blind spot, they have to drive there, and if you're paying attention you'll see them, you'll know where they are even when you can't see them in your mirrors directly. Don't just use your mirrors as a final check as you are changing lanes or making a turn, use them to maintain situational awareness around you.
3. Check your blindspot by turning your head and looking at it with your eyes before you make a lane change or turn. This is your last minute double check that your situational awareness map of what's around you is accurate. If you've been paying attention then this check will almost always be what you expect, but it's still valuable to double check (the belt and suspenders strategy).
4. (actually number zero) STOP FOLLOWING SO CLOSELY. Drive defensively, leave a decent gap ahead of you, don't drive for extended periods of time side by side with other vehicles (especially much bigger ones). This sets you up for success instead of setting you up for failure, it means you have a buffer on your reaction time. If you have an extra second or two of reaction time in addition to your emergency braking distance ahead of you then even if the car ahead of you comes to a dead stop right when you have your head turned for a split second to check your blind spot then you will still be able to come to a stop without hitting them when you bring your head back and react to what's going on, for example. Stack the odds in your favor, not against them. And don't let yourself be ruled by the dumb primitive impulses that tell you driving a car is always a race and you need to "win" and be aggressive and dominate others, etc, it's not any of those things, relax, concentrate on getting where you need to be safely.
P.S. Not checking your blind spots by turning your head is illegal in most states.
Some common mistakes I see people make:
Excess aggression, ego, and emotion. Check your ego, disconnect your self from instances of your work whether it's your code, your proposals, or your ideas. And be kind to others in criticisms, don't criticize (and especially not denigrate) other people criticize their code or their actions. Instead of saying "this is bad, why would you write this garbage?" say "here's a way to do it that I think is better for X/Y/Z reasons". The work is just the work, it's a collaborative effort to improve it. There should never be shouting or hurt emotions when hashing out designs or doing code reviews, work towards that goal.
Insufficient context. Make a habit of regularly summing up context in ongoing discussions and injecting it into the thread (email, IM, meeting, what-have-you). Do this explicitly when looping in new people to a discussion. The worst thing is to be looped into some long email thread and having to follow through the winding and convoluted discussion just to acquire context that could have been summed up by someone in the know with a few sentences. Even worse is when significant amounts of context are missing from the conversation because they happened in person or in other media or happened in previous discussions.
Unspoken assumptions. Much like summing up context stating your assumptions is critical to communicating effectively because it's so easy to assume that your little bubble of understanding is universal but it rarely is. And unspoken assumptions are one of the easiest ways for two people (or orgs) to be party to the same discussion and come out of it with completely different conclusions about what will happen next. And on that note, be clear when you're asking anyone anything, whether it's a question or a deliverable. Address them directly, use a question mark. You'd be shocked how often people fail at this sort of thing, especially in large discussion threads. Don't just leave pseudo-questions dangling, waiting for whoever is responsible to pick it up. Be direct, if you don't know who the responsible party should be, ask, maybe nobody knows and it needs to be determined/negotiated. If you know then make sure. And, of course, be polite.
Not going on the evidence. A close cousin to riding on unspoken assumptions, especially problematic in troubleshooting and debugging scenarios. Definitely a common mistake I see all the time in CS graduates (who, ironically, aren't very good scientists). Use the scientific method. Don't just make assumptions and tell stories that are convenient or kinda sorta make sense to you. Don't just "satisfice" by resting on the first semi-plausible answer you land on. Dig in, find the truth. Start with a hypothesis (or several), acquire evidence, figure out if you can for sure confirm or falsify your hypothesis (and competing ones) through the evidence. Keep coming up with other things to check that could provide additional evidence one way or the other, and competing hypotheses as well. Keep going until you have a rock solid "case" and can prove your theory. I have seen even very experienced developers screw this up countless times. They come up with some vaguely plausible cause for a problem and then spend way too much time operating as though it's true, without validating it first. And then they waste a ton of time and effort trying to "fix" the wrong thing. Just as often devs will put in a hacky workaround for a defect which just papers over the underlying problem. Pursue defects to their root cause, file bugs in your tracker to keep track of that information and put fixing it on the radar of the team/org/management so at least they are making a conscious choice if they choose not to fix it.