The "I can dig it" happens if you do DIG on any object other than I think the dirt. Just DIG alone is what tests digging in a room (except it only works in the starting room to find anything).
Do you have any good pictures of the tape? There's a Youtube video of someone playing it on hardware so you can see the tape inside of the machine, but no clear pictures of the real tape.
(Also, hello, I wrote the post! There's a part 2 where I finish the game, and I'll be doing the other Interact adventure game, Mysterious Mansion, in about a week.)
> Frankly, for most magic tricks the method isn't very interesting, although there are some notable exceptions where the method is fascinating, sometimes to the extent it can be far more interesting than the effect it creates.
> However, in general, most magic theorists and inventors agree that the method, for example, "palm a second coin in the other hand", isn't usually especially interesting.
Fair enough. It sounds like I simply fundamentally disagree, because I think nearly any explanation of method is very interesting. For close-up maginc, the only exceptions for me would be if the explanation is "the video you were watching contains visual effects" or "the entire in-person audience was in on it."
Palming is awesome. Misdirection is awesome. I fully expect these sorts of things to be used in most magic tricks, but I still want to know precisely how. The fact that I'm aware of most close-up magic techniques but am still often fooled by magic tricks should make it pretty clear that the methods are interesting!
Follow up questions will vary, but the bulk of most interviews is the same for every candidate, and candidates are then judged based on a rubric that is the same for every candidate (though often tailored to the specific role).
The consistency lets interviewers compare across candidates, and avoids the cognitive pitfall of defining a rubric after-the-fact that lets us hire the candidate who appealed to our lizard brains.
Even at startups, questions are also usually tested on several existing employees before it is used on the first external candidate, for calibration. Companies put a lot of time and money trying to hire for actual competence.
At big tech I am going to have to agree. At best it has allowed me to skip the phone screen. Beyond that, it's zero advantage. Even with a really high up employee.
The most direct way of solving the immediate problem is to make transitions idempotent. Why must it be an error to complete an already complete TODO? Completing an already complete TODO should be a no-op. That simplifies things greatly.
Of course many actions logically cannot be made idempotent, but for the subset that can, do it as much as possible.
There’s no denying that the idiomatic solution is sometimes far from obvious, but idiomatic react wants useEffect to only about synchronizing react with external systems. Everyone reaches for it to synchronize between components and do all sorts of other non-idiomatic things though, and that’s where the pain comes in.
> Insurance companies would be spending on cheaper preventions for all kinds of things instead of expensive cures if they operated like you describe.
The existing law has a massive defect that prevents any of that sort of thing from happening right now.
We capped insurance company profits as a percentage of claims, so the only way they can make more money is by paying out more and bigger claims. We basically banned them from having any incentive to lower costs because now lower costs mean lower profits instead of higher ones.
But that's a flaw in the existing system, not a flaw in the general concept.
> They'd be ripping a new one in the meat industry to forestall antibiotic resistance, for example.
There are already various state and federal laws restricting the use of antibiotics in livestock. But in general what leverage does an insurance company have over the meat industry?
I am not saying mature companies are "YOLO-ing" this randomly, but that many assumptions are made about how the input metrics trickle back to revenue/profits, and those can change. The attribution exists, but how it is done is far from an objective thing. E.g. how do you translate CTR into revenue ? How do you value an additional user ?
This can also be seen with cost saving. There are numerous examples on HN when people wonder why reducing the cost of something by X millions was not recognized (e.g. https://x.com/danluu/status/802971209176477696). Based on my own experience, most likely explanation is that's because there was no item related to this in the financial planning to be recognized.
That's true, they didn't have enough evidence to prove intent. Although having a low level staffer who had no business providing government IT services destroy the phones was unheard of, violated the law on how government records should have been handled, and highly suspicious there are also possible "valid" reasons for it, like protecting the information in those devices from being able to be recovered by anyone who dug the devices out of the trash, and the destruction of emails after 60 days could have just been to save space rather than specifically to hide evidence.
They also decided not to go after charges for the nobody staffer who did the deed, and controversially Hillary didn't face any consequences with the FBI saying: "To be clear, this is not to suggest that in similar circumstances, a person who engaged in this activity would face no consequences. To the contrary, those individuals are often subject to security or administrative sanctions. But that is not what we are deciding now."
You can use smudge and clean filters to expand this into something on disk and then remove it again before the hash computation runs.
However, I don't think you would want to use the SHA, since that's somewhat meaningless to read. You would probably want to expand ID to `git describe SHA` so it's more like `v1.0.1-4-ga691733dc`, so you can see something more similar to a version number.
The core of the system is simple - you list the third parties you send data to, you make accepting and rejecting equally easy.
Consider basically any popup on a popular website which: takes over most of the screen, makes "accept" the highlighted action button, requires going through "customise" to reject, sometimes requires unchecking categories manually, puts "save and exit" and "accept all" that so the same thing next to each other, either hide or not provide "reject all", etc.
There is no conspiracy here. You can either not use third parties, or if you do, your approval system doesn't have to be obnoxious at all, but almost every page makes it a shitty experience to 1. Make you accept out of frustration. 2. Make your angry that this is asked in the first place.
Yes, but the commit object (which includes metadata) references a tree object by its hash. The tree object is a text representation of a directory tree, basically, referencing file blobs by hash. So yes, you can recognize identical files between commits. It's true there's no fast indexing: if you want to ask the question "which commits contain exactly this file?" you have to search every commit. But you don't need to delta the file contents itself.
I would hope this environment would facilitate programming by making it even easier to look up how a module/function was defined, and when developing code, to quickly/easily plot output graphically/interactively so as to see whether things are lining up or no.
I actually need a data visualization tool at my day job, so I've installed it there, and begun working through the documentation/tutorials --- hopefully it will facilitate my wrapping my mind around a better solution for a recursive description of systems at work _and_ making a graphical interactive version available to co-workers --- if that works out, I'll try it out on my personal project.
Brings back memories. My first computer was a Heathkit-branded PDP-11 kit my dad assembled, with a dumb terminal, paper-type I/O, and no operating system. Later we had dual 8" floppies and a version of DEC's RT-11 OS, which was similar to CP/M. Read Byte magazine, and grew familiar with the names Altair, MITS, SWTPC, Imsai, etc., etc. Good times.
I can't wait for DJI to launch their mirrorless video-focused dSLR and smash everyone out there. I just hope that the tariffs are fixed before then so that it doesn't end up costing double MSRP here, which would absolutely kill the appeal of it.
Mostly because it is jarring for users that want to interact with tools which require these footers -- and the setups to apply them, like Gerrit's change-id script -- are often annoying, for example supporting Windows users but without needing stuff like bash. Now, I wrote the prototype integration between Gerrit and Jujutsu (which is not mainline, but people use it) and it applies Change-Id trailers automatically to your commit messages, for any commits you send out. It's not the worst thing in the world and it is a little fiddly bit of code.
But ignore all that: the actual _outcome_ we want is that it is just really nice to run 'jj gerrit send' and not think about anything else, and that you can pull changes back in (TBD) just as easily. I was not ever going to be happy with some solution that was like, "Do some weird git push to a special remote after you fix up all your commits or add some script to do it." That's what people do now, and it's not good enough. People hate that shit and rail at you about it. They will make a million reasons up why they hate it; it doesn't matter though. It should work out of the box and do what you expect. The current design does that now, and moving to use change-id headers will make that functionality more seamless for our users, easier to implement for us, and hopefully it will be useful to others, as well.
In the grand scheme it's a small detail, I guess. But small details matter to us.
The video is on YouTube somewhere. Having used Haskell and some dependently typed Haskell around the same time, I thought it was a fair assessment of state of play.
That sounds worth trying. And it would definitely be something to practice in advance...
When I've been aware of some of my hard-focused thinking behavior (am not autistic, AFAIK), sometimes I found I automatically tend to look away, at slightly interesting things (e.g., lines at the edge of a door or wall outlet, or some simple physical mechanism), and then sometimes it seems like 1% of my cycles are contemplating that. While the rest seems to be reasoning in all sorts of ways about the immediate problem and related things.
(In an interview, this is balanced with my awareness of the interviewer's mental model, and also thinking about the job opportunity that's the real point of the exercise.)
I don't understand how that works, but it usually works very well for problem-solving outside of interviews.
If I tried to switch up that automatic process, by closing eyes, I don't know whether the habit of visually contemplating something in parallel is a Chesterson's Fence, and then the magic wouldn't work.
Though, would be funny, if you were in an interview, trying this eye-closing tactic for a hard-thinking problem for the first time, just so you wouldn't look like a cheater, and you find this puts you in some other mental mode. Combat Mode, for example, where maybe you're suddenly finishing the interviewer's sentences, disregarding things they say you think are irrelevant, redirecting and cutting to the chase, with a calm but energized and commanding manner. You might get permabanned from that company, for coming across like an aggressive jerk, but they started it by creating a jerky interview process. :)
Excellent article, and I appreciate how you gave an overview of solutions that didn't make sense for you but were otherwise important to know about.
Could you expand on how your pathfinding works for both ground-based and flying enemies? I've been trying to wrap my head around how to handle this on my own game, and trying not to invent a wholly separate solution for enemies than can avoid obstacles vertically.
I might just not be aware of a better alternative for React hooks, but I don't like useEffect. I feel like it makes it much more difficult to manage state and transitions compared to SolidJS or other frameworks that use signals.
Do you have any good pictures of the tape? There's a Youtube video of someone playing it on hardware so you can see the tape inside of the machine, but no clear pictures of the real tape.
(Also, hello, I wrote the post! There's a part 2 where I finish the game, and I'll be doing the other Interact adventure game, Mysterious Mansion, in about a week.)