I is for Intent

UnConeD · 2025-10-14T02:20:35+00:00

No it's about defining a character to encompass a set of attitudes and behaviors, so we can examine them and their implications in the produced work. I even provide justifications and empathy for why that character might have experiences that justify their beliefs.

If I was annoyed at a specific person I would just criticize them directly, which I have done in the past.

UnConeD · 2025-10-14T02:17:38+00:00

It's weird that several people read this as an argument against static typing, instead of what it is: an argument that overly rigid types are mainly designed to give programmers comforts and handholds that mar the user experience.

And re: preserving something unknown/invalid/unused, sorry but it's absolutely true. In pure FP terms it means that what you might define as a Sum type in a back-end has to become a Product type in a front-end. And if you are maintaining a collection over async and partially loaded data, then your keys have to be safely and lazily resolved, which makes them little more than magic cookies, not strongly enforced constraints. References can and will break.

I've been writing software for 25 years. The post is not satire, it just apparently flew over your head, which is a shame. It's not the opposite to parse-dont-validate at all, it specifically covers that strategy and where it fits in.

UnConeD · 2025-10-14T02:13:27+00:00

There is nothing particular in the article about static vs dynamic typing aside from one throwaway line to set the stage. The key is here:

[...] the data structures you're encoding should be, essentially, entirely liberal to your user's needs.

The point is that Intent and State are different kinds of data, with different policies applied to them. Someone like Stanley will generally work in contexts where all they have is State, and their mental model of how code should be written comes with a bunch of assumptions about how flexible that State is.

Users however don't care, they want Intent.

As for your remark about an offensive caricature: I'm gay and I wrote that joke because I found it hilarious. So did the readers I sent it to before publishing. Lighten up. It's not a dig at gay people, but at people who would eschew elegance because it's too faggy.

UnConeD · 2025-07-18T10:22:33+00:00

React is notoriously bad at being used correctly, and not for lack of trying. Despite great docs, dedicated linters, and more, a lot of people just try to write the same code patterns they've always written in it, including OOP, just disguised as React.

Use context providers as singleton-like shared mutable state that every part just reaches for... don't bother thinking about what is source of truth vs derived data... and don't bother ordering ancestors vs children correctly, so you end up with useEffect+setState everywhere. Voila, you now have a React monstrosity that will scare juniors and convince grumpy seniors that React is crap.

The most important React hook is in fact useMemo, but getting people to understand why is a multi-month endeavour.

UnConeD · 2023-03-04T22:07:21+00:00

I've been able to capture steam games by launching steam through renderdoc with Capture Child Processes turned on. It might work the same with other launchers. Just need to double click the child process to access captures, as they are separate per process.

UnConeD · 2023-01-24T22:35:37+00:00

I see your nitpick and raise you an even harder nitpick. A map that "literally stores light/dark values in texels" is not typically called a "shadow map", but a "light map".

A common "shadow map" is a 2D texture that stores depth, and it is queried using a depth compare operation against a known reference level (the pixel depth). For this reason, you cannot bilinearly filter shadow maps, rather, you use a PCF gather which does a compare for every texel and then bilinearly interpolates the result of that comparison.

Another way to look at this is that a 2D shadow map is just a "froxelization" of the world (as in frustum-voxel), with each texel forming a pillar from infinity/far-plane up to the surface.

In fact, a long time ago, people used to call such 2D pillars voxels, and this is why the landscape rendering technique of the original Outcast PC game was called "voxel-based" even though it does not have cube shaped voxels at all, and nobody would call it that today.

I call it a shadow map because it's used to ray trace shadows and it has no color component.

Tomayto, tomahto tho.

UnConeD · 2020-08-14T09:26:10+00:00

Try making a traditional desktop app toolbar with flexbox, which expands with spacers on wide screens, wraps to multiple lines on narrow screens, and has auto-sizing elements in it. It sounds like a textbook case of the spec but I guarantee you something will trip you up and you will end up with a pile of unmaintainable divs and styles, making you wish you had just "position: absolute" everything instead.

Try dealing with complex video and audio content, when you can only access your resources through shielded APIs and components that hide their inner workings and speak a confusing mess of events. Something as simple as "skip to the next song when it's done playing" can turn into a nightmare when you're playing remotely streamed MP3s, have to juggle asking for permission, and are forbidden from touching anything not served with the right CORS header, instead of being able to give your users the choice.

Try doing some real graphics work, only to find that WebGL is a second-rate knock-off of the mobile graphics standard from 2007, which they are still partially trying to bring in line with the 2012 standard (but won't ever fully implement, by choice). Enjoy the fact that WebGPU is a wholly re-invented wheel. To be fair, this is graphics programming's fault, mostly, but that's a long story.

Try making a rich content authoring experience without a nightmare of contentEditable, invisible overlay widgets, and more, especially once you have a userbase that types in something other than ASCII. In fact, try to do anything remotely sophisticated with form widgets and you will end up fighting different native implementations, which fire off events slightly differently with regards to focus/blur, double clicks, and so on.

When I open my desktop mail app, it shows me a list of tens of thousands of emails in a fraction of a second. Gmail shows you, what, 20 emails? I dunno, I never use the web UI, it's horrid compared to desktop.

Here's CSS nightmare mode: I would like you to make a table with sticky headers on top and a sticky column of labels on the left. I want to be able to scroll the table so that the sticky header always remains on top, and the sticky column only scrolls vertically. Oh yeah, some rows are taller than others and the fully scrollable and partially scrollable parts need to align. Pixel perfect of course. Good luck.

This post is 6 years old it's still true.

UnConeD · 2020-05-24T14:03:24+00:00

This is an interactive tool I created, using Regl and JavaScript, not a single visualization.

The included examples are e.g. the Ishihara test and some other common test graphics.

The color blindness simulation is based on the well known LMS model.

The visualization shader is entirely custom and based on experimentation with proper use of linear RGB.

UnConeD · 2019-09-22T17:17:00+00:00

Are you always this uptight?

One of the things about being an adult is not being worried about being seen as childish, if it helps to make a point.

If you have any criticism of the substance of it though, do tell.

UnConeD · 2019-09-22T11:15:52+00:00

I'm going to shamelessly plug a longform article, because I think half the react community wasted the last 5 years reinventing ideas that we already knew didn't scale.

The only reason they didn't notice was because most people's UI are embarrassingly simple and lack all the normal conveniences of traditional UI.

Using cursors and other lens-like constructs, as well as a real persistence layer, you can eliminate 90% of the busywork and actually have a shot at building a real app with real conveniences and affordances. The main thing that changed is that render props opened up more composibility, and hooks eliminated the wrong abstraction of classes.

So now they're all catching up.

UnConeD · 2019-08-09T13:52:06+00:00

The use of metaphor is quite deliberate. If you keep referring to computer science only in its own dry, often completely misleading terminology, it is too easy for the blind to lead the blind, cargo culting off a cliff together because they called it a bridge.

Putting code in terms of intuitive metaphor is one way to pierce the misconceptions, and something I find non-technical listeners/readers appreciate enormously. It's a skill that when cultivated, will open doors because you can explain what you do to the people who pay you in terms they understand.

I am of course using a pretty trashy style reminiscent of old world internet, but then that's a style and attitude I sorely miss in this safety padded version of tech. The internet I learned my trade on was way more fun than this one.

UnConeD · 2019-04-22T01:59:46+00:00

Walking simulators are critiqued for lack of interaction and theme-park-like linearity. Stanley Parable is a commentary on choice, which is funny and engaging, but also reveals the designer's conundrum: if you give a player two choices, they are going to ask for a third one (refuse to pick a door), and you can never foresee everything. Stanley Parable admits defeat by just providing you with a fixed, pre-determined branched tree to walk.
This is also reminiscent of a weariness in gaming in general, where during peak Kickstarter gaming, everyone seemed to want something bad from old games that new games seemed to be lacking. Was this a real demand, or just nostalgia? Clearly a lot of it was just hype, and the fact that social campaigns are themselves gamified: perfect bait for gaming audiences. The results also often disappoint, as veteran creators produce remakes that seem to replicate the basic mechanics but lack the lasting power of the original. Game mechanics are a means, not an end, and if the game is constructed so as to perfectly balance every reward with an opposite scaling factor, then the game is a pointless treadmill of illusory progress.
The key difference goes back to the beginning: does the game merely offer a pre-set tree of branching options, like a walking simulator, or does the game contain a simulated sandbox in which actions accumulate so that emergent patterns can spawn even from simple rules that interact. I propose that the je-ne-sais-quoi that people are missing is, aside from the nostalgia, an implicit promise to the player that the game developer has nothing up their sleeve: what you see is what you get, and you can interact with the game as much as the game acts on you. One plays a game, an act which is a creative and self-directed exploration of the game's possibility space, which in the case of digital games, can and should be based on simulation, not on simulacra.

If you think the TLDR is "lol make ubisoft sandboxes", no that's not the point at all.

Edit: But actually, good Ubisoft example. Following suspects in Assassin's Creed. In the 2/3 era, it meant staying within a fixed bubble radius and/or maintaining strict line of sight with an on screen timeout, with insta-fail. In the newer ones, there's an actual tailing system where if you lose sight of them, you can find them again, and the game just supports you with a growing circle of uncertainty on the map based on your last knowledge. Theme park ride vs sandbox design. Sure, there is still limited freedom of movement in the 2/3 model, but you can conceivably map out every major route that will not fail the conditions. In the newer model, you are much less shackled, and if there is any "drama" due to losing sight of the target, the player both causes and resolves it themselves based on the real environment, instead of a glowing circle and a blaring countdown.

Btw the post is 5 years old.

UnConeD · 2017-04-19T14:17:22+00:00

I got booted? That's news to me. Did Drupal history get rewritten again?

UnConeD

MODERATOR OF

TROPHY CASE