skysight-inc/HackerNews huggingface dataset:
my own experience as someone who used to be very extroverted:

extroversion was meeting a social expectation. i had good social skills and people relied on me to carry social situations. i could entertain, organize and predict needs. i earned that expectation to feed my ego and then became trapped in a vicious cycle.

then i had a fresh start after moving to a new city for grad school and have done my best to avoid any vocal leadership for anything because i know what can happen. organizational, behind the scenes leadership is ok. i wonder how many extroverts would rather be introverts given the opportunity and some introspection
TL;DR:

- use principles as guidelines not gospel

- optimize for readability/maintainability

- and for the love of all that's holy, don't build stuff you don't need yet.

BTW, any other old-timers remember when we just wrote code without worrying if it was SOLID enough? Those were the days...
Got it, thanks. But it seemed from your original post that you tend to write state machines a lot more than the usual engineer does, would that be correct? Would you use this in a crud rest API for example?
Ozs don't need to feel so isolated. Their continent is moving north towards China & will one day ram into it.
Damn AGI got hands
if you fix the one based indexing you should call yours KT@ or Kt`
> I believe you are confusing ones that are stored in software or syncable (Passkeys) with the hardware backed credentials (platform authenticators).

The problem is that the protocol allows websites to require use of the latter. If the two were indistinguishable to the website, then passkeys would be a good thing.
> but being in that certain state of mind is "a lot %" of what's needed, and it actually takes no energy or comfort

Your mileage may vary but it certainly takes energy to maintain a state of mind which doesn't come naturally to you. This is bound to affect your comfort eventually. Since there are degrees of intro/extroversion, it may be easier for some people to will themselves across that divide.

It's like floating on water. Some do it naturally, effortlessly, they even rest and relax while doing it. Others have to flail around under the surface to do it, putting in effort and consuming energy.
A cute and thought-provoking theorem for sure, but arguably none of the three given criteria for clustering are well motivated, so the result is much less relevant than usually claimed.

- scale-invariance: stretching data along some dimensions should not change clustering.

This is clearly not true: . . . (three well-spaced spots) may be reasonably seen as three clusters, whereas ||| (three nearby elongated bars) not.

- richness: all groupings must be reachable.

Also not quite true, both of the two cases: (1) all clusters are singleton points and (2) a single cluster that contains all points, mean the same: no useful cluster structure found. So it is enough if one of these groupings are reachable, and not both.

- consistency: increasing inter-cluster differences and decreasing intra-cluster differences should not change clustering.

Also not quite true: suppose we have 9 clusters:

. . .
. . .
. . .

now move the points so that the columns get further apart, at some point we will get:
| | |, where 3 clusters are more reasonable.
could it be we just tend to be slower devs in general?

like I doubt I am blazing on windows 11 and VScode either.
I’m setting aside UE because Blender isn’t and was never trying to be a game engine. When it comes to high-end physics sims of any kind— particles, pyro, rbd, liquid, cloth, hair, etc– blender isn’t close to Houdini. The blender toolkit will get ‘something’, but the Houdini toolkit will get you ‘anything.’ More broadly, it’s so easy (well, “easy” like you don’t have to modify the program source. This stuff is going to be complex and fussy no matter what) to infinitely control absolutely anything using everything from node-based no-code stuff (VOPs)that compiles down to performant machine code, to their built-in c-like for performant calculations in complex networks (vex), to popping in nodes where you can write your own openCL if you really wanted to, all animatable using anything from key frames to their built-in non-time-bound math system (CHOPs… I know… the names…) originally built to process wave-level audio. If you’re clever enough, you can even use all of that to drive your geometry, audio and shaders to some extent simultaneously, without (textual) code. The geometry nodes in blender are cool, and they seem to be developing them the right way – ensuring quality rather than racing for feature parity with bifrost or Houdini or wherever — but last I checked you couldn’t even animate their parameters. Huge progress, a great tool, and many people’s preferred tool for modeling. Frankly you wouldn’t catch me dead sculpting in Houdini, and Houdini has a way to go before their compositor is on par with Blender’s, even if the procedural bent makes it more useful for some unusual use cases now. But for the really deep procedural stuff and simulations, anything involving volumes, and also fitting into complex pipelines, we’re talking etch-a-sketch vs oil paints. Imagine if blender started as a purely procedural tool and only focused on that use case? The differences would go so much deeper than the feature list would let on.

I think the differences are a lot less significant with other modeling-focused DCCs like Maya, Max, and C4D. All great programs in their own right. Maya really is an incredible tool for character animation, C4D is so killer for motion graphics type stuff… but they’re all much closer to blender for their intended use cases.
It's not good but it's the best we've got. There's a reason the most common alternative to distro dependency management involves shipping entire copies of other distro with a few adjustments inside of a sandbox to make sure it doesn't conflict with the other copies of other distros.
> Now that every modern language a package manager...

...they fail to integrate with dependencies written in any other language.

It's fine if you just want to sit a monoculture language software stack on top of a multilingual base platform. You can't make a functional system with one language alone, yet those who criticise distribution packaging architecture do so while simultaneously depending on this ability that language-specific package managers do not have. There is no viable alternative today. Most critics think they understand the general problem but only have narrow practical experience, so end up believing that their solution is superior while not considering the general multilingual software supply problem.

Nix isn't a solution either, because in the general case Nix isn't security-supporting arbitrary and multiple dependency versions either.
There are some hairy edge cases during registration that many get wrong. (At least GitHub and google had this bug) that if create() returns but the passkey never reaches the server due to bad networking conditions that your password manager thinks it can log in but the server never recorded the passkey for the user. Basically there is no transactionality and you can get in a split brain situation where your password manager and your server don't agree and it's very confusing for end users.

https://github.com/w3c/webauthn/issues/2038

They apparently came up with a fix for this using something called Signals API but I don't think any browser implemented that yet.

Just wanted to highlight that this part of the UX is hairy and hard to get right
> We are all descended from a long line of people who lived extremely social lives.

This is an incorrect rationalization of your own prejudices, nothing more.

> I wish y'all would accept that it's just hard, but worth it.

You need to accept that your personal experience is not universal. It's one of the most basic realizations a thinking human needs to have.
Hertz is asking EV renters if they want to keep it, permanently
Is anyone else like me? A little socializing goes a really long way for me. I don't hate it, it's not exhausting, I can do it well, and I'm generally seen as a fun person to talk with.

I'm an introvert but not because my "social battery" is discharged by socializing, but instead because I need to discharge in solitude

I have unlimited social stamina and can do it forever, if by forever you mean that if I'm left in socializing without that necessary solitude I will spin off into mania and eventually get in serious trouble
I don't think that's correct for the sys_exit() call with no outputs: the compiler doesn't know the syscall instruction has side effects, I think it would be within its rights to omit that asm statement without volatile. Adding an output and code to consume the result seems like a waste of space in .text, it doesn't return.

It reminds me of a funny little bug in ARM Linux, fixed by adding volatile to an asm statement: https://lore.kernel.org/lkml/92a00580828a1bdf96e7e36545f6d22...
Our juniors write horribly complex code that senior devs have to ask to simplify. This happens all the time. And the juniors simplify and thank us for teaching and mentoring. It’s a big reason we do reviews. So we can control how dirty the code is before merging and so we can grow each other with constructive feedback. Sometimes it’s also just “LGTM” if nothing smells.

90% of comments in my team’s PRs come with suggestions that can be applied with a click (we use GitLab). It requires almost no effort to apply suggestions and it’s often not much extra work for reviewers to explain and suggest a concrete change.

I agree that reviews should be used pragmatically.
Only one way to fix that!
You forgot to mention variables are global by default, just like javascript.
Seems like you just did the most cursory of searches, found a negative pull quote about some studies in one chapter, and called it day. Much like reading the negative google reviews for a bar you were invited to instead of actually accepting the invitation and going, I'm not sure this qualifies as "checking it out"
I think it ruins the people fighting for the leaderboard spots but thats a small percentage of people. Everyone else just does it for fun or creates custom leaderboards with their friends and it'll always be fun
Why is the goal to get something "stable" in the first place?
Climate on earth never was and never will be stable, so this should not be our goal in the first place.
The goal should be to keep the change fairly slow because most living things have trouble with fast changes. That's it we don't need more than that.
One of the nice things about TV/movies that you don't get with books is a "shared experience": you can't read a book with your girlfriend or your family, but sitting on the couch with your girlfriend and watching a movie is totally normal and enjoyable.
Yes, I'm indirectly saying that the way many contemporary apps are managed sucks. Python's packaging experience is fine as far as tools in that category go. The trouble happens when packages are abandoned, or make assumptions that are bad for users. Even if everyone was a good package author, there would be inevitable conflicts.

The problem extends way beyond Python. This is why we have Docker, Snap, Flatpack, etc.: to work around inadequate maintenance and package conflicts without touching any code. These tools make it even easier for package authors to overlook bad habits. "Just use a venv bro" or "Just run it in Docker" is a common response to complaints.
It's the distro packaging that makes it hard to exercise freedom 2, and it always has been - frankly when distro packagers intervene in language packaging it's always done more harm than good. Distributions still don't have good answers to installing packages locally, or even installing two versions of the same library side by side, and it's not reasonable for that to hold back packaging and development progress. (There are good solutions to this problem, but they look more like Nix than like traditional distro packaging).
Okay, there it is: [0]. It mostly implements a version of CPS transform from "Compiling with Continuations, Continued" by A. Kennedy [1], figure 8. Two main differences in the output language from the one in your post is that, first, this version binds everything to temporaries (including literals and continuations), and second, it uses "let" (with multiple definitions, so it's actually "let*") as the primary name-binding feature instead of immediate application. And I use name "$ret" instead of "$call-cont".

The main point of interest is the use of CpsExprBuilder as an accumulator and explicit looping over sub-expressions instead of using meta-continuations, as is popular in most papers on CPS transformations. This is not the only possible way to implement such CpsExprBuilder: another option would be to have a mutable CPS expression with a pointer into it, and gradually grow it. But since you can't just take a pointer to a list's element in Python, you would probably have to keep a whole path (as, say, an array of indexes), and re-traverse the tree every time you append to it, like this:

result = {
'expr': ['let', [['#t0', 2], ['@k0', ['cont', ['#t1'], None]]], ['f', '#t0', '@k0']],
'path': [1, 1, 1, 2],
}

cursor = result['expr']
for index in result['path'][:-1]:
cursor = cursor[index]
cursor[result['path'][-1]] = ['g', '@halt', '#t1']

I've tried this approach, and even when it's encapsulated in a class, it's way too easy to accidentally end up with a random None somewhere deep inside your resulting expression. So instead, the expression's tree is turned inside out, so to speak. It's similar to using an explicit stack instead of using recursion.

[0] https://gist.github.com/Joker-vD/7cddcfada042ed486dd74690ae9...

[1] https://www.microsoft.com/en-us/research/wp-content/uploads/...
That's a valid take, and a good reason for your library (and other software using it) never being included in major distros. You're not obligated to make your code work with specific distros.

It's a good reason for others to avoid your libraries, though, especially if they do intend to be compatible with common distros.

The openssl issue was just the result of openssl being unnecessarily complex and difficult to work with, though.
Because the videos in YouTube premium still have ads. But because the ads are built-in to the videos by the "content creators" themselves, they call them "sponsor segments". YouTube Premium doesn't include SponsorBlock.
> sorry, not to nitpick, but I am really not a fan of one-based indexing

It is very funny how this is just the one sole criticism that always gets brought up. Not that other problems don't exist, but they're not very talked about.

Lua's strength as a language is that it does a lot quite well in ways that aren't noticeable. But when you compare things to the competition then they're quite obvious.

E.g. Type Coercion. Complete shitshow in lots of languages. Nightmare in Javascript. In Lua? It's quite elegant but most interestingly, effortlessly elegant. Very little of the rest of the language had to change to accomodate the improvement. (Excercise for the reader: Spot the one change that completely fixes string<->number conversion)

Makes Brendan Eich look like a total clown in comparison.
I can't think of any effective marketing in my entire life that didn't involve repetition.

I think when people say they need to learn marketing they really mean they want to learn to skimp on spending on marketing.

Nothing anyone could come up with for 1 or 2 passes would really beat a white background with black text that just says https://nuenki.app that the target market sees 10 random times for 10 seconds.

I am hopeless at marketing because I think it is just that stupid at this scale of market size and being good at it goes against all my sensibilities.
Exactly, any price that isn't what I want is proof that natural supply and demand system is broken, a truly collective crisis where we must all sacrifice something for my greater good.

I mean, why is nobody talking about the devastating nationwide shortage of new cars? No matter where I look, I can't find any even when I offer a whole $1,000!
I would add "A Bivvy, a Phone and a Drone: Cycling Home from China"[1] to that great list. As well as Ed Pratt Unicycling The World series [2]

[1] https://www.youtube.com/watch?v=Mmdxs_0yYwc

[2] https://www.youtube.com/playlist?list=PLocRYksAqGOJnr-Y0eyP8...
Spoiler: change your air filter.
Deception, Lies, and Valve [video]
It is fascinating once we consider how little, both of technology and mobility scientists had in the past. To verify some little fact they had to wait months, years.
I don’t think it’s so simple. Brains are complicated and everyone is different.
- Documentation is great, but documentation can fall out of date. Strong types usually can't; they are checked in both directions.

- Tests are great, but it's hard to maintain 100% coverage that checks all of what types do. It's very possible to have tests that pass that shouldn't. Types can not only find stealthily broken code, but also broken tests.

- Type checking gives even more instantaneous feedback than almost any test runner.

- Most projects have multiple developers. Types don't communicate everything, but they are a reliable form of communication that is guaranteed to be up-to-date even when documentation isn't, which is great combined with good function names and good parameter names.

- Most programs need to deal with requirements that shift, either because they evolve or our understanding evolves. Refactoring code without types is hard: if you change the return value of something, how can you be sure that all of the usages are up-to-date? What about if your refactor has been rebased a number of times before merging? I've run into a real-world production incident caused by this, when a return type changed to a tuple and it only exploded in an important Celery job that didn't have a test around the specific boundary that broke.

"If you know what you're doing" is not enough. Programs change, and they are changed by multiple people concurrently. This is the same reason why Rust continues to grow, people can say what they want but moving errors to the left is the only way forward because even if you're literally perfect you still have to know 100% of what's going on to never merge anything that causes a problem. (But really, people are not perfect, and never will be, so better tools Will win eventually.)
It's not just the well-known GitHub, Shopify, Chime, Figma, Zendesk, Convertkit (Kit), Coinbase etc.
See the "few" companies here, actively hiring Rubyists for no reason https://rubyonremote.com/remote-companies/
Square, Gitlab, Cisco, Figma, Instacart, Block, Calendly, 1password, and so on
That's a fascinating approach.

And it gets me a bit sad about the state of WebGPU, however hopefully that'll be resolved soon... I also on Linux am impatiently waiting for WebGPU to be supported on my browser.
It is because type inference has become a standard feature in most languages so you don't have to type AbstractBeanCounterSingletonFactoryFactory all the time.

Also the duck typing crowd were rebelling against polymorphism and over-used meta-programming OOP slop, not against types per se.
> The upstream OpenSSL code was broken: it was invoking undefined behaviour.

No it wasn't. It was reading indeterminate character values, which has defined behaviour (char cannot have a trap representation).

> the Debian maintainer had asked upstream whether it was OK to remove the code

They hadn't asked the correct mailing list, and they only asked at all for one of the two cases where they removed similar code, which wasn't the one taht caused the problem.
Ever since I stopped doing this I’ve been much happier. Now that I’m old I don’t feel pressure to conform to social norms, I just do whatever I want. If that means I don’t see anyone else for weeks who cares. In my youth I felt so much pressure to be social and it’s just not what I want to be doing.
Love me some quake style terminals, will check this out
Well, neither have outputs, doh, so they both need volatile don't they?

Adding an output for the %rax result would prevent the call from being omitted without volatile (assuming it is actually consumed by something), but it could still be reordered, right? I suppose with general syscalls that might be okay, but certainly not with sys_exit().

They also need memory clobbers, but I don't think memory clobbers would necessarily prevent reordering? In the case of the ARM bug though, it did: https://lore.kernel.org/lkml/Zqa4SAyPKPuaXdgg@mozart.vkv.me/
I have been waiting to try this out for sometime now. I recently tried various terminal emulator tools and I settled on wave terminal. This is a list of these tools for reference. I would list tools that are on both MacOS and Linux which is comparable to this new emulator. But also because I did not try any on windows.

- Alacritty (https://github.com/jwilm/alacritty)

- waveterminal (https://github.com/wavetermdev/waveterm)

- Hyber (https://github.com/zeit/hyper)

- Kitty (https://github.com/kovidgoyal/kitty)

- Rio (https://github.com/raphamorim/rio)

- Tabby (https://github.com/Eugeny/tabby)

- Wezterm(https://github.com/wez/wezterm)

- Contour (https://contour-terminal.org)

- Extraterm (https://github.com/sedwards2009/extraterm)

- Warp (https://www.warp.dev/)

I didn't like that Warp is VC product as I don't like essential tool like a terminal in my workflow to be dependent on proprietary VC product.
Can you elaborate what you don’t like about this one, LC-3, in particular? I’m not familiar with it, but just had a look at it on Wikipedia. After your comic, I was expecting something weird, but upon a quick glance, it doesn’t seem too jarring. A bit like a mixture of s/360, some x86, and a tiny bit of ARM (or other RISCy architectures). With lots of omissions and some weirdness of course, but the goal seems to be to quickly come to a working implementation. I’m curious what exactly you think makes it “worse than useless” for teaching.
Krishnan should pay a media relations firm to generate fake allegations of some sort. Then Loomer would have to support him.
India is unique case of a bit from the south that moved at high speed, smashed into the north, creating Himalayas.

My son went trekking there came back with a stony fossil of some deep sea creature thousands of miles from ocean today!
Every major tech company is Visa now, it's not 1993 anymore
Economists dropped $10M in rural Africa. It changed economic science forever [video]
Thx for this! Is good to see that we can still interoperatividad.

I did and presented something on these lines 11 years ago! When multiple ruby runtimes were a thing.

https://speakerdeck.com/brutuscat/jruby-experiences
> doesn't sound like a good idea.

It isn't, but that ship sailed when cpp was invented.

> Keep it stupid simple

Could not agree more. That's why I use Lisp.
Lua used to be very popular for embedding because the runtime was minuscule so it could run in very constrained environments (like old consoles). This is mostly a non-issue these days though.

JS and Lua are very similar feature-wise and I imagine Lua hasn't gotten the massive JIT runtime optimizations that JS has, so JS seems a far better choice these days.
i have tried o1with some credits and i can confirm it is very addictive