stillkicking

It's not a caricature if it's taught at supposedly elite institutions of education, into which admission is contingent on a declaration of adherence to said ways of thinking.

Even if that were true, I'd still not put any faith in the empathy skills of people who use e.g. "incel" as a slur, who claim "it's okay to be white" is hate speech and who call arson, vandalism and looting "mostly peaceful protests" because the in-group did it.

Spanish-speaking non-binary people are hopefully not so stupid as to conflate a lack of appetite to rewrite the entirety of Spanish grammar with a refusal to acknowledge someone's existence.

The issue I have with WASM is that its threading model is basically the web-worker model: each thread has to have its own module and can only communicate through pure data via shared memory.

TS/JS can do a lot these days, but threading is its achilles heel. Mechanisms like green threads and fast n-way dispatch for parallelization are basically still out of reach.

You can emulate some of this with WASM and worker pools, but it seems like you'd need a fair amount of boilerplate to actually make that work properly. And if you want to interface with native web APIs, you're stuck with the same limitations.

e.g. You can share memory with a web worker, but if you want to pass handles to resources around, you are extremely limited and it requires a custom approach for each particular API.

Twitter hired tons of employees since 2020 so the apparent massive layoffs simply weren't. And there is a lot of dead weight at tech companies regardless.

Political pundits had a direct interest in sabotaging the perception of Twitter as an authoritative source of new information, and the coordinated attempts to get advertisers to pull out early on also point in this direction.

The reason they aren't talking about it anymore is because, by and large, this plan failed, and those predictions weren't predictions but wishes. Some groups slinked off to Mastodon, which works for niche communities, but doesn't work for the site at large.

React doesn't provide a systematic answer for handling state in apps if data is flowing up, down and sideways

So let's first back up and recognize that this earlier statement was flat out wrong. React does provide a systematic answer for this.

Second, not only does it have a systematic answer, but it memoizes quite well because React will not re-render children if the `children` prop is identical to the previous render, even if you don't use `memo()`. This means it is quite cheap to have context providers update, even if you nest 2 or 3 of them.

The big issue with React in my experience is just that developers are lazy af and will stubbornly refuse to read even the tersest of docs even if they are encountering a new paradigm, like declarative and reactive UI. The result is a giant spaghetti mess of their own creation, which they then blame the framework for.

You can make React fast and you can keep it clean, all you have to do is topologically sort your data by the frequency of how quickly it changes. That's it. That's the trick.

One thing I find funny is the problem of data loss. On macOS, it's been the norm for years that applications retain their state when quit and re-opened, including unsaved documents.

While weird when introduced, in hindsight this is exactly the right behavior, because it is the most user-friendly and it makes e.g. software updates a non-issue. Even apps like iTerm can be updated and restarted in-place, retaining all the sessions.

It's a testament to how bad Linux UX still is that this sort of idea is not only utterly alien, but instead some developers thought it was acceptable to kill running apps outright.

This injected CSS will remove the popup:

    body article.newsletter-post.post .subscribe-dialog,
    body article.newsletter-post.post .subscribe-dialog-scroll-modal-scroll-capture { display: none !important; }

I don't really care about Elon Musk as a philanthropist or not. He's like a one-man Apple in that way.

But.

- The environmental problem with electric cars is undoubtedly due to the batteries, both the manufacturing and the fact that the cars are much heavier as a result. But the idea that without electric cars more people would choose for alternative modes of transport is a bit dumb. The cars are inherently luxury vehicles, and in many places, the infrastructure isn't there for a low-car/car-free lifestyle.

- You don't need hyperloop to derail high-speed rail investments and projects. Simple bureaucratic ineptitude and red tape will do that. Like that story of how SNCF pulled out of California and went and built trains in Morocco instead, which was cheaper and more efficient.

- What's a huge technical liability is a bloated govt space agency that takes decades to deliver projects at 100x the cost of what a commercial vendor can do, while all the people who originally built the tech are retired or about to. And all that cost isn't just money, it represents an enormous amount of time and resources spent. Chastizing SpaceX for rejuvenating the space industry seems pretty ridiculous.

It seems like you're just taking Musk as a convenient target to blame, because he should spend his resources more "wisely", but each of the examples you cite is actually due to an enormous systemic ineptitude elsewhere.

Hello. I am rational developer. I am very clever and very rational. Devoid of emotion. Oh what is this? Someone implies that there are objective standards of quality in a field I know little about? Someone who has used something for decades to do deep work, and has built up deep experience, implies they know better than Joe R. Random, or the people who are currently maintaining it? What is this bubbling feeling in me? Insecurity? No way. I am rational. Therefor these opinions must be objectively stupid and purely based in taste and emotional and wrong. I can tell because the author used a swear word, and swear words mean they are angry and thus incorrect.

Two can play at this game.

Just from a visual balance point of view, the new settings panel doesn't remotely match the intent of Aqua UI. The fact that they are then putting scrollable panels in the _middle_ of a _side_ of a window, with a sticky part both on top and at the bottom, shows you they don't particularly know where shit should go.

Making changes for the sake of making changes is by itself pointless busywork. But ignoring the established practices of desktop UIs to make them more in-line with touch UIs is destructive.

This is why you should never finalize specs until you've written the documentation for it.

If it sounds stupid when you say it out loud, it _is_ stupid.

A node.js back-end.

This is a detail, but it's imo illustrative of how refined Apple UI is and how easy it is to get it wrong.

The design of how the Dock scales and animates follows a very simple principle: if the mouse is outside the dock, and you move towards an icon vertically, entering the dock does not shift that icon around. Because that would make it feel "jello" and uneasy, like this imitation.

Scrollbars are actually a real pain to implement.

- you first need to lay out the scrollable content normally, without a scrollbar

- then you need to detect whether it spills over, and whether a scrollbar is needed

- if so, you need to lay out all the content again, in a slightly smaller area

- if the content ever shrinks, you need to detect this too

- and if the content only _just_ fits, then it is possible that without a scrollbar, it doesn't need a scrollbar, but if there is a scrollbar, it needs to be scrollable. Chicken and egg.

This is actually pretty nasty to get right. Now factor in layout models like flex box, which also require part of the content to have a "pre layout" pass done in order to estimate "natural size", and it can get quite gnarly. And if you want to mix vertical and horizontal layouts... oof.

I got an equivalent of HTML/CSS box+flex working in Use.GPU but it took plenty of iteration.

I think the lesson here is that UI is always more complicated than you think. There are countless little tricks and mechanisms that you would only ever notice it if they didn't work. When they do, it is so "obviously" right you literally can't tell.

(As an aside, whoda thunk that a generation raised on participation trophies would be easily triggered???)

(Yes this is an alt)

- Make vague generalizations about white people, men

- Blur the distinction between non-credible fringe groups and some of the most credentialed institutions around so you can play the underdog

- Ascribe all actions taken in name of minorities as the express wishes of those minorities, even if they are ineffective or destructive

- Frame it as redress for hundred years of "history" (read: the specific grievances of North American colonialism)

- Wrap it all up in a blue=good red=bad American apple pie with a Trump bow while simultaneously deriding others for being too set in their ways

There are colleges that are demanding _diversity and inclusion loyalty pledges_ with adherence to a _specific socio-political agenda_, and you think "science is political" is just stalling from people who have lost perspective?

The American left is insane and delusional.

It's only a spectator sport if you're not downstream from those changes though.

I also think ageism is only part of the problem, it's stubbornness in general. Even if you're younger, it's difficult to translate hard-earned experience into respect because many engineers are infatuated with their own designs and algorithms. I've had people reject my advice even though I literally worked 2 years on app dedicated to solving that specific problem we were having. Of course they had egg on their face at the first demo. And they're still using that broken code.

*is a game developer with a particular focus on "RETVRN TO TRADITION" where anything that isn't super lean-and-mean is bloated and inefficient and ridiculous, and only exists because web developers are misguided, miseducated, etc. WebRTC could do what he wants, but then he'd have to build a WebRTC->pure UDP gateway.

I can sympathize, but, even in the original discussion on Twitter it's clear he is ill-informed of the relevant security fiascos that made all these complicated protocols necessary, or the messy legacy constraints they must operate under. Infrastructure is not magic, and tying together e.g. application-level concepts with DNS-level concepts would be a recipe for misery IRL.

I also find it funny he considers the string/text-based parts of HTTPS to be unworthy of a secure protocol, when in fact, the whole reason that approach is considered so dangerous is because of programmers with his attitude who underestimated the difficulty of secure parsing. The niche of "LangSec" is all about solving this problem properly by treating input processing as a formal parsing problem with formal grammars.

Thesis:

The application event loop coalesces these damage rectangles and initiates an optimized operation: it only redraws views whose bounds intersect the damaged region, and also passes the rectangle(s) to the drawRect:: method. (That's why it's called drawRect::).

So, according to this, you need an explicit run-time mechanism to optimize the interaction of parents with children, with some form of coalescing.

Antithesis:

This is another reason why it's advantageous to have a stable hierarchy of stateful objects representing your UI. If you need more context, you just ask around. Ask your parent, ask your siblings, ask your children, they are all present. Again, no special magic needed.

...except here, where OP says you don't need any special magic to deal with parent/child relationships: just reach up/down/left/right and do your thing!

Synthesis:

The reason one-way data flow became so popular is exactly because the second view is a trap, or at least, a local maximum. If you are really doing complicated orchestration in your hierarchy, then you will end up reinventing the first wheel, to avoid expensive/inefficient parent/child/parent thrashing cascades.

React does in fact have a good solution for this, in the form of contexts. These also allow you to reach up and go talk to parents, in a controlled yet composable way. The way I describe them is "singletons but with scope". An underappreciated benefit is that you can extend a parent context and pass it down, replicating some of the benefits of inheritance, without the messyness of subclasses.

Where React falls short is that parents can't respond to children without re-rendering themselves, which ironically makes implementing e.g. nested tree widgets hard, even though the result is all tree-shaped.

Functional effect systems which can re-join after forking, and gather yielded values, do not have this issue, and I wish React would explore this avenue instead of the all the React 18 stuff they've been doing lately... it feels too much like they are leaning into the same Facebook "dumb read-only UI" style that the article correctly laments. They are straying away from React's original appeal, which was that it was "just the V in MVC", and instead becoming very opinionated on how server side and client side should be combined. Meanwhile the challenges of how to replicate complex legacy desktop UIs remain mostly unaddressed, with the official advice about event handlers, state and effects falling short by a mile.

This explanation is useless imo because it expects the reader to already understand the weirdest part:

"If I have a function A -> B, how could I possibly get something that goes in the direction F B -> F A out of it?"

The answer to this is: given e.g. a function that accepts a B, i.e. `B -> ...` you can compose it with `A -> B` on the _input side_, to get a function that accepts an A, i.e. `A -> B` (+) `B -> ...` = `A -> ...`.

Once you've managed to get that across, you can start talking about contravariant functors. But expecting people to just intuit that from the condensed type signature is pedagogical nonsense.

...and you will show your users stale data, which is a non-starter for a chat app. You will then need to implement some custom push/invalidate mechanism, based on a custom interpretation of the DB event log.

The entire point of the Fire* style of database is that these trade-offs are not worth it in the long run, that few development teams have the skill and time to implement this themselves, and that databases can and should solve this for you.

I have little love for Cloud Firestore, it's a trash fire riddled with poor decisions, but if you don't even understand what the problem is with that SQL query, you don't understand the expectations users have nowadays of front-end applications.

Relevant post: https://status451.com/2016/01/06/splain-it-to-me/

There are two common social perspectives: information sharing vs emotional harmony. From one perspective, the other seems rude or insane. If your message is corrected or added to, this is a chance to be less wrong. But it is also a chance to be embarrassed and seen as less knowledgeable than you seemed.

Status seekers tend to assume the latter perspective, and therefor label such comments as rude, dismissive, conflict-seeking, etc. even if the OP had no such intention.

This is also 95% of what "help i'm being harassed online" comes down to.

Every time someone argues something based on the merits of Go, I can't take them seriously anymore.

Things CSS got wrong:

- not supporting tables in CSS1, even though they were the dominant layout mechanism used at the time.

- `box-sizing: content-box` as original sizing model, which nobody has ever needed.

- `::pseudo-elements`, also used to convince people that having to add extra divs or spans to HTML is a horrible mortal sin to be avoided at all costs.

- the cascade / `!important`, causing endless rule precedence wars.

- `ems` as units relative to the parent instead of the root font size

- making flex-box alignment props the most confusing thing ever

- `display: none` to exclude elements, instead of an `exclude` prop, colliding with the display model

- `position: fixed` not making sense

- `text-overflow: ellipsis` not working in most cases where you'd want it to

I could go on for a while.

Java got its slow reputation mainly because any early encounter with a Java applet would proudly display the Java logo and then cause your computer and disk to thrash for 30 seconds.

Then Java developers heard this, confused it for "Java executes slowly" and so they never fixed it, until Java applets just became obsolete.

People always focus on the big issues because they are not hypothetical at all.

We are talking about a platform that has had dubious fact check warnings attached to tweets for a year now, which mainly seem to serve to reinforce a false consensus and prevent open debate.

People being bullied, harassed, doxxed, etc are a distraction from this larger issue, and will not benefit from this, because the only ones you ever hear about are people with enough influence and clout to turn being a target into being a public victim.

In many ways he's understating the problem. At least there used to be file formats to support, and files to lose. But how much of the data you interact with daily is even directly accessible to you? How much of it can you access when you're offline?

Take Slack. You can install it locally, but that doesn't matter, because it won't start without an internet connection, and its local storage is completely opaque. Compare this to a mail client, where everything is stored locally, indexed and searchable offline, and can be exported into a universal albeit messy MIME format, as well as imported into other accounts.

Of course this is necessary for the business model, the Slack free-plan event horizon wouldn't be effective if it only applied to which new data you can sync down... and if users only discovered this when e.g. moving to a new computer, they would quickly start to wonder why they can't just transfer the data they already have themselves.

With Google Drive, your 'docs' are just placeholders pointing to the cloud. You can export them individually to Word or print them to PDF, but it's a manual process, which you will likely only think of when it's too late.

For an example of how this can really matter: an acquaintance is embroiled in a legal dispute with an ex-employer. Thanks to Apple's sane implementation of IMAP Mail on iOS, she still has access to all her company communications there to use as evidence. Unlike on her PC, where she was just using webmail the entire time and has nothing.

The incentive in the cloud age is to create dysfunctional products that provide an illusion of permanence instead of the reality of tangibility. I expect this is only going to become a bigger problem over time.

"How can a site be both a Church of SJWs and an alt-right shithole?"

If one side is committed to flagging content off into invisibility, and another is committed to debating that practice, then you end up with this situation. There does not need to be any symmetry in behavior, and it does not mean the site is both or either of those things.

It just means you have some religious SJWs who call everything they disagree with alt-right, regardless of people's actual political self-identification or their desired policies. It means that SJW tactics are allowed to work, and that they are successfully casting the blame onto their own targets. It's like a social prisoner's dilemma where one defector castigates the other for not cooperating.

I invite you to show posts that advocate SJW ideas in a polite and neutral tone that have been flagged off the front-page, rather than debated. Given that opponents of SJWism tend to favor free expression on principle, I highly doubt you can find them in any number.

If you don't want the meta, keep the object-level clean.

If anything is a hallmark of bad ideology, it's making a mock summary of other people's thoughts so you can valiantly take it down from a distance without ever engaging with it.

This happens every time when a post or thread exposes the social justice orthodoxy for the pernicious and self-centered bullies that they are.

The original announcement about Rafael leaving LLVM was flagged off the front page too: https://news.ycombinator.com/item?id=16982837

Remember LambdaConf? Those posts also ended up several hundred items off the front-page, without being visibly flagged. https://archive.is/iI5NA

HN maintains plausible deniability and claims that it wants to keep ideological warfare and flamewars out, but the pattern is too obvious for that to be believable, because only one side of the argument consistently gets flagged away.

Yep. The extremeness of e.g. The_Donald on reddit is a direct result of how hostile r/politics was to anyone who didn't support Hillary. Sadly, I think the far left actually likes it this way. They want unreasonable boogiemen they can point to and demonize, so their own echo chambers can pretend to be the moderate ones.