3,628 karma · joined December 27, 2018
If the thing you're shipping isn't meant to be a dependency for other projects, then semantic versioning doesn't really fit.
In trunkver though, using the timestamp of the build time is a little weird, since you could inadvertently end up building an earlier version of trunk at a later time.
Putting an identifier of the job that built the release in the version number also seems heavy for what could just be an entry in a log file for when you need those forensics.
It was super unhelpful when trying to do version control forensics. But if I'm being generous, I think maybe he was trying to remind everyone that anyone can put anything in their identity config, and we shouldn't trust whatever is in there for all that much.
To see the nature of the race condition, just put some print statements in some strategic locations and then see the interleaving, out of order, duplicate invocations etc that are causing the trouble. It's hard to see this type of stuff with a debugger.
git diff --color-words --word-diff-regex='\w+|.'Start with the absolute gnarliest, high-traffic, most intricate UIs that are in production now. Design your components to accommodate those most important and valuable use cases, in partnership with the teams responsible for those interactions. If you can handle those, and if you can get those developers to prefer your components because they're easier to work with and they solve the problems the existing tangle is solving, then you will win. Everything else after that will be smooth and easy and it will work.
On the other hand, if you design in isolation, you will likely end up with another beautiful "living style guide and component library" that no one ever uses, because it is not flexible enough to handle real-world interactions, where the designers and product people and engineers all have hard-won legitimate strong feelings about how it all should fit together in the actual product that's making all the actual money.
In fact, it seems a misplaced goal in the first place, for a news organization presenting itself as an authentic source of information, acting in the public interest -- to invest so much in a format that is fundamentally inauthentic.
Could this be part of the reason that listenership is declining?
It cannot be more secure to store it in a password manager than not to store it at all. The email recovery path exists in either case, so that part is a wash.
On the anxiety aspect, I think my point is that -- okay, exercises and workbooks can have their place, but the real way forward is to have a thorough understanding of the task at hand and provide your constructive criticism and help your team make their way.
If you need more context, ask questions. If you need to poke and prod to understand how the pieces fit together, then poke and prod. With all of that knowledge you can have a productive conversation about the proposed changes.
On the other hand, without all of that, then it is guaranteed to be anxiety inducing, since with your review, you are taking some amount of responsibility for a thing you may not sufficiently understand.
Here's my advice: Focus on whether the change actually solves the problem it's trying to solve. Run the code; does it work? What regressions could it cause? Is there any way it could be simpler?
Along the way, you may notice style guide offences, or minor nitpicks. It's good to take note of those things, but only raise those issues once you've addressed the fundamentals.
At the end of the day, confidence comes from understanding. So dig in and understand the context, understand the effects of the change, and give the best feedback you can to help get to the best solution.
Here's how to do it: use Tailwind only for layout (margin, padding, flex) and brand consistency properties like text size, line height, colors etc. Beyond that, anything that requires changing presentation based on state, embrace CSS. It was meant for this, and remains the best solution. Invest in learning CSS because it will still be here in 20 years.
I have a hard time internalizing the jq query syntax, and am not overly excited to invest in learning all the quirks when it's not based on a widely-adopted open standard. Maybe `JMESPath` could be the way forward.
Sometimes `gron` can be a pretty great alternative approach, depending on your use case. At least it is very intuitive and plays nicely with other tools.
> While Automerge optimizes for working offline and merging changes periodically, Pigeon is optimized for online real-time collaboration.
So after just a second or two, you might be able to know with certainty that a bunch of small directories are small, and then that a handful of others are at least however big has been counted so far. And that could be all you need, or else you could wait longer to see how the bigger directories play out.
Maybe there could be an iterative breadth-first approach, where first you quickly identify and discard the small unimportant items, passing over anything that can't be counted quickly. Then with what's left you identify the smallest of those and discard, and then with what's left the smallest of those, and repeat and repeat. Each pass through, you get a higher resolution picture of which directories and files are using the most space, and you just wait until you have the level of detail you need, but you get to see the tally as it happens across the board. Does this exist?
I can see how this is frustrating to some, but sometimes that's how the priority nets out. It looks like the bug was triaged, investigated, took its time finding its way to the right developers, and now a fix will land soon.
This is mostly just the process working. I for one, am grateful for these folks' good work.
function random() {
random._s = random._s || 11224; // seed
return (random._s = random._s * 16807 % 2147483647) / 2147483646;
}
Wikipedia says this approach has been around at least since the 1950s.It is the case that with completely generative models, you will get hallucinated details very likely to be untruthful. But with this approach, you can see blurry input images of license plates that with our naked eye we could not possibly decipher the characters, then put through this model where the output is very close to the actual ground truth.
https://dachunkai.github.io/evtexture.github.io/static/image...
Where does this information come from? It seems they are generating synthetic "event camera-like" events just from diffs between still frames? So maybe they trained a model based on real events from a real event camera? It's hard to tell from their write-up. But these results are very impressive.
And for what? In Node specifically, it's not as if esm actually solves any real problem! In the greater ecosystem, sure it has some benefits, but Node doesn't even have to choose. Just support both at once, like bun and build systems have for a while, and let's move on from this nonsense.