mjfisher

Indeed. Real life hacks are beginning to sound like Neuromancer.

It says something about the state of the world that I was genuinely uncertain whether this was actually a joke right until the last paragraph.

Very well done.

That's interesting and actually the opposite of mine. I wonder if it's stack or methodology dependant? For reference I'm usually using cursor and opus4.6 and for a bigger piece of work:

- Start in ask mode - "I'm planning on doing X to achieve Y; are there any alternative approaches? What problems might I run into?"

- Chat for a bit and get the high level approach, switch to plan mode and ask for a nicely formatted plan

- What's kicked out is already in the rough shape of the discussion so far, so it's a case of following a nicely formatted doc through and highlighting sections of text and asking for clarification or changes

- Hitting "build" and then reviewing what's been done

For a new service I might spend an hour in ask/plan mode - but then it gets 95% of the build itself right first time.

Do you do the same with different results, or is there a different stack/methodology you go through?

I can't speak to this particular case, but most of the delay is likely to be organisational rather than technical at this kind of scale.

Don't think about how hard it is to migrate a VM to a new provider. Think about how hard it is to:

* Get procurement to sign off on a new vendor

* Guarantee that your ISO compliance standards can be met under the new regime

* Make sure that GDPR requirements are met during any data transfer process to the satisfaction of your legal team

* Get the old infrastructure team and the new infrastructure team coordinated enough to be able to plan a migration without downtime

* Mollify the consultants that the CEO's friend said he should hire

* Analyse the migration plan to death to derisk it while at the same time be unable to actually evaluate it small scale due to the points above

How could that possibly, ever have made it through. Every single API for every single service didn't check the JWT?

I think the specific case of having a long conversation with an agent about what you're trying to achieve and why, and then have it update a README or a skill based on that conversation is a useful thing to do. Captured the context of the conversation without having to essentially write the same thing again.

That's usually because the system that runs those things is independent of the timing of the main game loop. And then when someone finally gets around to implementing the pause screen, they still run even with the main game time stopped. And you look at it and think "eh, you know what - looks cool - we'll leave it".

I hope most people have a broader definition of "relevance".

The reintroduction of Red Kites to the UK has been a huge success. I don't get particularly excited by birds normally, but regularly seeing such large creatures (almost 2m wingspans) curving through the sky is nothing short of majestic. They're almost reminiscent of dragons.

I wonder if I'll get to feel the same about golden eagles soon too.

Just to sanity-check my reading of this:

- Zustand exposes itself as a hook.

- MobX does that observer-wrapper thing

- Snapstate instead has an explicit writing step (`scoped()`) at the bottom of a component

If so, I really quite like that. Kudos!

I tend to use things like pyenv or nvm; they keep python and node versions in environments local to your user, rather than the system.

`pip install x` then installs inside your pyenv and gives you a tool available in your shell

It's fine, just not stellar. It was terrible (UX, speed, consistency) ten years ago. It's better now - mostly gets out of people's way and just works. It doesn't delight me.

Can anyone recommend good alternatives to Jira? Things that keep me defaulting to it:

- Scales well from simple configuration and workflows to more complex multiboard views/custom fields/layouts per issue type etc

- Good OOTB integration with common CI/CD - see PRs, deploys etc from each ticket

- Good (adequate?) integration with their wiki in Confluence

- JQL for being able to do custom reporting tooling (get me all issues transitioned to X status in this time period)

Things that frustrate me:

- Complexity/UI around configuration

- Very poor kanban metrics reporting

I think there's definite scope for that being true; not because you can start doing stuff before you understand it (you can), but because you can ask questions of a codebase your unfamiliar with to learn about it faster.

I think that we don't and can't know is part of the point

Serious question: what are those things from windows 95/98 I might miss?

Rose tinted glasses perhaps, but I remember it as a very straightforward and consistent UI that provided great feedback, was snappy and did everything I needed. Up to and including little hints for power users like underlining shortcut letters for the & key.

Could you give a few examples? I'd lean towards adjusting tooling if you can.

My spelling is often horrendous and I know it - but almost every dev I know of prefers to copy and paste anything that might be misspelled just because it's easier than taking the risk.

Similarly - how does does this get anywhere near causing a production outage?

I'd be tempted to view this as a blessing in disguise; this person sounds like they'll trip up more often than the rest, but if one individual can cause a production outage with spelling mistakes something's gone awry with your processes elsewhere. You have an opportunity to fix whatever that is now.

Is there a way of getting them to store a dozen or so totp secrets? And if so, how do you select which one you want to use?

Cheaper for everything, ultimately.

A triangle by definition is guaranteed to be co-planer; three vertices must describe a single flat plane. This means every triangle has a single normal vector across it, which is useful for calculating angles to lighting or the camera.

It's also very easy to interpolate points on the surface of a triangle, which is good for texture mapping (and many other things).

It's also easy to work out if a line or volume intersects a triangle or not.

Because they're the simplest possible representation of a surface in 3D, the individual calculations per triangle are small (and more parallelisable as a result).

And in case it helps further in the context of the article: traditional rendering pipelines for games don't render fuzzy Gaussian points, but triangles instead.

Having the model trained on how to construct triangles (rather than blobbly points) means that we're closer to a "take photos of a scene, process them automatically, and walk around them in a game engine" style pipeline.

I'm on mobile; I scrolled to the bottom and clicked the image of the painting and could zoom in to my heart's content - did it ask you for an account?

Fascinating reading:

The majority of developers are unacquainted with features such as processing instructions and entity expansions that XML inherited from SGML. At best they know about <!DOCTYPE> from experience with HTML but they are not aware that a document type definition (DTD) can generate an HTTP request or load a file from the file system.

I was one of them!

Nope, it's not a coincidence - it's an interesting exploration of the history of the definition of a metre. Read the article.

As it says, at some point there was an attempt to standardise the length of a metre in terms of a pendulum's length; which related it directly to g through Pi.

Perhaps not all that offtopic - Hatetris is what happens when you subvert normal the rules and make the game play against you. Anti-mimetics stories are what happens when you subvert the rules of ideas and make them play against you.

I can imagine a common space of inspiration there.

Most recently, Elixir.

I never really lost my love for programming, but twenty years in the n-th commercial project in the more common languages (plus a front end based in whatever combination of JS frameworks is the new flavour) really ground a lot of the original creative joy out of it for me. The interesting bits got too easy and the hard bits got more uninteresting.

Elixir is a breath of fresh air; it's purely functional so it requires thinking a bit differently, but it's accessible enough to start easily and pretty enough that it's not a soup of parentheses (looking at you, lisps). It's practical and well suported enough to build a wide variety useful things, and very good at concurrency.

It's what I really wanted Ruby to feel like.

The author mentions those at the bottom of the article, but two problems highlighted still remain:

* There's another intermediary concept (kernel density estimation) between the audience and the data

* They're still likely to misrepresent tight groupings and discontinuities, which will be smoothed out

There's a difference between asking someone to invert a binary tree, and asking someone to sum up a list of numbers. The latter finds the people who can't code much more quickly!

That's often not true. Testing more, earlier, tends to surface problems whe they require less work to fix.

Easier context switching, less dealing with extra added complexity between coding the issue and fixing it etc.

I'm surprised no one yet - either in the comments or the article - has talked about the most important and powerful part of Scrum: having a singular sprint goal aligned with a higher level product goal that the entire team is dedicated to.

That it's also the most difficult or commonly ignored part of Scrum might also be relevant.

I kind of do, but the lack of sleep has killed my short term, long term and working memory. The time before is hazy.