unconed

A software cursor is manually drawn by the graphics stack, which saves what was under it, draws the cursor, and then whenever it needs to be moved, writes the original data back, saves the data at the new position, and then draws the cursor there.

AFAIK this hasn't been true for a long time on most platforms, certainly on macOS. The desktop image is composited on the GPU by assembling the underlying windows with appropriate effects like shadows and scrolling/scaling. A software cursor is just another overlay which may also have a transparent shadow.

Actually preserving what was under the cursor and putting it back is the sort of thing you wouldn't do anymore, because that's a cache which requires babysitting based on everything that's underneath and around it.

e.g. On macOS there's full screen zooming for accessibility, and if you wiggle the mouse, the cursor grows in size briefly (maybe even too big for hardware cursor to support).

In 2011 the iPhone was ~4 years old and iPads were ascendant as the only tablet game in town. Google was still playing catch up with Android as a knock-off, having just debuted Android Honeycomb.

The actual topics are:

- the Apple campus that is still unique today

- a rectification of an urban legend about Jobs and Knuth

- a clip showing Jobs was prescient in the late 90s about personalized cloud tech

Dismissing the focus on Jobs as a cult of personality is a mistake, he was simply very influential, and so was Apple at this time.

Meanwhile LLMs are the antithesis of the Jobsian style: just cramming pirated data into a model and reselling it as fake intelligence without real source attribution.

My "oh shit" moment with AI was when an industry where licensing was the cornerstone of projects and employment contracts decided to just adopt pirated code without any source attribution.

The other one was when a CTO boss sent me an AI proposal to review and the experience was like being gaslit by a con artist.

Many professional developers have started acting like the kind of employee that previously would've been fired after 3 months.

Woke lost, because it infected companies, universities and other organizations. It prompted entitled idiots like cited above to go into projects started by others, assume eminent domain, and attempt to take it over with slander and defamation. Always with the same script, pretending to defend while engaged in an unprovoked and drawn out attack.

See the cases of:

- The Ada Initiative

- DongleGate

- James Damore

- Bret Weinstein and Evergreen state (there's even a documentary by Mike Nayna about this)

Just to name a few.

Hyperventilating over the phrase "woke mind virus" or calling Musk a nazi a few dozen more times will not work.

You're the square, and your favored ideology lost.

We now even have BlueSky serving as the verifiable echo chamber of the idiots, and it's absolutely hilarious how they just can't stop attacking each other over there.

Calling for sources while questioning one of the most visible forms of social activism of the last decade is pure gaslighting btw.

Asm.js was never needed as a legacy mechanism, as it was just a compilation target for native code. There was nothing that it needed to remain backwards compatible with, all asm.js code was new code.

https://acko.net/blog/on-asmjs/

Hm so not only is it possible to manipulate scores on HN with weird scripts, but mods only noticed this when users pointed it out in this instance, with no automation or logging there to detect something like this?

Do you suppose motivated individuals might have used something like this to bury wrongthink at a time when mods insisted such a thing wasn't happening, and even if it was, it was happening to all tribes equally so really it wasn't a big deal?

It's not that AI can't convince a novice that what comes out is passible.

It's that experts in a field generally agree that what comes out is insidiously hollow garbage.

This isn't a "semi-religious" belief. It's linear token soup and diffusion bakes running headfirst into actual expertise, second and third order effects, refined skill and taste, and so on.

If you actually want to see civilization advance, you cannot rely on machines that merely mash up existing intellectual output while pretending to have expertise.

We already had that in the form of art school avant-gardism. AI is just style transfer of that, with corporate sycophancy and valley hyperbole as a veneer.

After making one of the least worst rich editors out there on the web, they needed to keep their developers and designers busy (while not having time to fix privacy bugs).

Like every other AI tool it mainly seems to exist to produce productivity porn. Summarize the meetings nobody could be bothered to summarize. Write the docs nobody can be bothered to read or write. Communicate as an end, not a means, because the company your work for has transitioned into the dead-weight phase.

This article's timeline is mostly accurate, but contains a few inaccuracies:

- Unified toolbar and titlebar dates from much earlier... it was 10.4, not 10.7.

- The brushed metal look was supposed to be applied to "appliance-like" apps as opposed to "document-like" apps... But Apple was never able to stick to that rule themselves.

There are a few design ideas that always turn out to be bad when implemented, but which designers seem to have to learn the hard way. Transparency is the biggest one, but I guess so is excessive rounding now.

Despite the quick spread of agentic coding, institutional inertia, affordability, and limitations in human neuroplasticity were barriers to universal adoption of the new technology.

Blaming lack of adoption purely on regressive factors follows the same frame that AI firms set. It isn't very effective satire for that reason.

It couldn't be that there is something essential and elementary that is wrong with the output, no... all these experienced experts are just troglodites and wrong and we should instead tag along with the people who offloaded the parts of their work they found tough to a machine the first chance they got.

There's no such thing as ape coding. There's still just coding, and vibe coding.

The news article isn't an obituary, it's gravedancing. Hope that enlightened your royal majesty.

He died in his sleep last month

Title is misleading.

Wizardchan, a smaller and misogynistic forum for male virgins

I see the media has learned exactly nothing since the days any of this was relevant. Just apply the usual adjectives until consensus is achieved.

There's nothing more credible than sockpuppetting a dead person to renounce anything related, amirite?

The degree to which people defend poor scholarship and writing on HN these days is frankly pathetic.

There is nothing about that intro that is offensive. Reading comprehension ought to tell you that "pun intended" is a joke to make the bitter pill that OP wrote garbage easier to swallow.

Homework assignment: make a bode plot of the convolution filters [1 1 1] vs [1 2 1].

Which one turns +1, -1, +1, -1, .. into all zeroes?

You ought to know this because the fourier transform of [1 0 1] is a cosine of amplitude 2 on the complex unit circle e^(i*omega), which means the DC quefrency needs to be 2 to get the zeroes to end up at nyquist.

The frequency response H(z) (= H(e^i*omega)) of [1 1 1] on the other hand will have its minimum somewhere in the middle.

Also here's a post that will teach you how to sight read the frequency response of symmetric FIR filters off the coefficients: https://acko.net/blog/stable-fiddusion/

Using a caesar cypher as an intro without explaining the pro tool and framing the educational context properly is just shit pedagogy bro.

Go look up what a z-transform is, and begone.

A binomial is exactly equal to a repeated 2 sample box blur yes. That's exactly how you construct pascal's triangle.

For filter sizes > 2, box blurs are ass.

Before you get your pitchforks out and call me an AI luddite, I use LLMs pretty extensively for work.

Chicken.

Seriously, the degree to which supposed engineering professionals have jumped on a tool that lets them outsource their work and their thinking to a bot astounds me. Have they no shame?

Sorry but this post is the blind leading the blind, pun intended. Allow me to explain, I have a DSP degree.

The reason the filters used in the post are easily reversible is because none of them are binomial (i.e. the discrete equivalent of a gaussian blur). A binomial blur uses the coefficients of a row of Pascal's triangle, and thus is what you get when you repeatedly average each pixel with its neighbor (in 1D).

When you do, the information at the Nyquist frequency is removed entirely, because a signal of the form "-1, +1, -1, +1, ..." ends up blurred _exactly_ into "0, 0, 0, 0...".

All the other blur filters, in particular the moving average, are just poorly conceived. They filter out the middle frequencies the most, not the highest ones. It's equivalent to doing a bandpass filter and then subtracting that from the original image.

Here's an interactive notebook that explains this in the context of time series. One important point is that the "look" that people associate with "scientific data series" is actually an artifact of moving averages. If a proper filter is used, the blurryness of the signal is evident. https://observablehq.com/d/a51954c61a72e1ef

It's bizarre how casually some people hate on Musk. Are people still not over him buying Twitter and firing all the dead weight?

_Especially_ because emotional safety is what Twitter used to be about before they unfucked the moderation.

cough

The Strange Case of "Engineers" Who Use AI

I rely on AI coding tools. I don’t need to think about it to know they’re great. I have instincts which tell me convenience = dopamine = joy.

I tested ChatGPT in 2022, and asked it to write something. It (obviously) got some things wrong; I don’t remember what exactly, but it was definitely wrong. That was three years ago and I've forgotten that lesson. Why wouldn't I? I've been offloading all sorts of meaningful cognitive processes to AI tools since then.

I use Claude Code now. I finished a project last week that would’ve taken me a month. My senior coworker took one look at it and found 3 major flaws. QA gave it a try and discovered bugs, missing features, and one case of catastrophic data loss. I call that “nitpicking.” They say I don’t understand the engineering mindset or the sense of responsibility over what we build. (I told them it produces identical results and they said I'm just admitting I can't tell the difference between skill and scam).

“The code people write is always unfinished,” I always say. Unlike AI code, which is full of boilerplate, adjusted to satisfy the next whim even faster, and generated by the pound.

I never look at Stack Overflow anymore, it's dead. Instead I want the info to be remixed and scrubbed of all its salient details, and have an AI hallucinate the blanks. Thay way I can say that "I built this" without feeling like a fraud or a faker. The distinction is clear (well, at least in my head).

Will I ever be good enough to code by myself again? No. When a machine showed up that told me flattering lies while sounding like a silicon valley board room after a pile of cocaine, I jumped in without a parachute [rocket emoji].

I also personally started to look down on anyone who didn't do the same, for threatening my sense of competence.

1) A system that needs _seconds per tile_ is not suitable for real-time anything imo.

The irony is that you explicitly posited your thing as a successor to Perlin noise when in fact, it's just a system that hallucinates detail on top of Perlin (feature) noise. This is dishonest paper bait and the kind of AI hubris that will piss off veterans in the scene.

2) I'm also disappointed that nowhere is there any mention of Rune Johansen's LayerGen which is the pre-AI tech that is the real precedent here.

Every time I see a paper from someone trying to apply AI to classic graphics tech, it seems they haven't done the proper literature study and just cite other AI papers. It seems they also haven't talked to anyone who knows the literature either. https://runevision.com/tech/layerprocgen/

3) >The top level input is perlin noise because it is genuinely the best tool for generating terrain at continental scale

This is a non-sense statement. I don't know what you are thinking here at all, except maybe that you are mistakenly using "Perlin" as a group noun for an entire style of functions.

Perlin has all sorts of well-known issues, from the overall "sameyness" (due to the mandatory zero-crossings and consistent grid size) as well as the vertical symmetry which fails to mimic erosion. Using it as the input to a feature vector isn't going to change that at all.

The idea of using plate tectonics is much better, but, vastly _different_ from what you have done. And btw, every plate tectonics simulation that I've seen does not look convincing. If you treat it as a simple transport problem, the result just looks like a Civilization 1 map. But if you want to treat it seriously, then the tectonics have to be the source of all your elevation changes, and not just some AI hallucination on top afterwards. The features would all have to make sense.

Your abstract states that classic terrains are "fundamentally limited in coherence"... but even to my non-geologist eye, your generated heightmaps seem incredibly blobby and uncanny. This makes me think that a real geologist would immediately spot all sorts of things that don't make any sense. For example, if you added water and rivers to the terrain, would it work, or would you end up with non-sense loops and Escher-like watersheds?

(mostly I'm disappointed that the level of expertise in AI tech is so low that all these things have to be pointed out instead of being things you already knew)

The solution to seeing more Bret Victor-ish tooling is for people to rediscover how to build the kind of apps that were commonplace on the desktop but which have become a very rare art in the cloud era.

Direct manipulation of objects in a shared workspace, instant undo/redo, trivial batch editing, easy duplication and backup, ... all things you can't do with your average SaaS and which most developers would revolt for if they'd had to do their own work without them.

Recently I tried to hack in a feature into Transmission for Mac. All I wanted to do was add a single checkbox per torrent, which corresponded to a property in the libtransmission back-end, but which isn't exposed.

And sorry, but, it was a complete mess from start to finish. Instead of just mapping a boolean value to a state, the entire read and write path was this elaborate game of telephone. In React I would just use something like a cursor to traverse and mutate state immutably, and the rendering part would take care of itself. There was also a bunch of extra code to remember and apply defaults, which in a more functional system like React is generally managed via composition.

One of the article's claims is that the React model is suboptimal because UIs are more stable than it assumes. But this isn't true because the edge cases is what you will end up spending the most dev time on.

A declarative approach lets you achieve N features in mostly O(n) lines of code. When you do things imperatively, you're instead having to orchestrate up to O(n^2) state transitions in O(n^2) lines of code.

The React model is also not that different from immediate mode, which is very popular in games, where performance is important. The main difference is that React has an answer to what happens when you can't fit all the work into one rendering cycle, via memoization and sparse updates.

This gets you similar perf to classic retained mode, but without all the tedious MVC plumbing.

PS: Here's how i use patching as a basis for state management, https://usegpu.live/docs/reference-live-@use-gpu-state

Changes in mood result from changes in behavior.

If you don't feel like doing something you know is good for you, do it anyway. You'll feel better afterwards.

Apple already went through this before with PowerPC -> x86. They had universal binaries, Rosetta, etc. to build off of. And they got to do it with their own hardware, which includes some special instructions intended to help with emulation.

TOML is basically a formalization of the old INI format, which only existed in ad-hoc implementations. It's not really a "language", just a config data syntax like JSON. It doesn't have major footguns because it doesn't have a lot of surface area.

The various features it has for nesting and arrays make it convenient to write, but can make it harder to read. There is no canonical serialization of a TOML document, as far as I can tell, you could do it any number of ways.

So while TOML has its use for small config files you edit by hand, it doesn't really make sense for interchange, and it doesn't see much use outside of Rust afaik.

Event sourcing gives you all the technical overhead of replayable transactions while giving your end-users none of the benefits (e.g. undo/redo). It's purely an infrastructure-level feature that only makes auditors and sysadmins happier.

Because the person whose job depends on keeping the customers happy is not the same as the person whose job depends on making spreadsheet numbers go up.

The semantics of React code are very different to imperative straight line code.

Yes and all you have to do is learn why those semantics exist in order to do react well.

Unfortunately too many programmers still think they can just mimic other code to figure it out.

The old fogeys don't rely on printf because they can't use a debugger, but because a debugger stops the entire program and requires you to go step by step.

Printf gives you an entire trace or log you can glance at, giving you a bird's eye view of entire processes.