et1337

Is the goal to be able to change a design token and see that change reflected across all your various UIs? How do you ensure people remember to use the design token instead of hardcoding the value? Won’t you still have to check every nook and cranny of the UI to make sure the change doesn’t break anything?

And if that’s not the goal, what is the goal?

Okay, I think that probably describes the charter school my wife taught at, though it was not run for ideological or profit motives, it was inner-city.

The key though is this point:

> gets money from the state, usually a bit less than a public school would, for each attending child

So the charter is under the same pressure as the public school since compensation is directly tied to headcount, the top priority is keeping kids or you won’t survive. I’m not sure how the schools you’re mentioning are able to push kids out and not lose money. Maybe they’re just in affluent areas.

All that to say, I’m not a huge fan of charter schools but I doubt they’re the source of our problem.

I’m realizing the term “charter school” is probably overloaded.

The charter school my wife taught at (in CA) had to prove itself to the district and fight for public dollars, hence the inability to lose any kids (and dollars).

The charter school I went to years ago sounds more like the kind you’re talking about. Basically a private school that received no public funding.

Half of her kids had special education needs. You “demand special ed evaluations” and the result is, the kid comes back to your class with an IEP and congratulations, you now have to create an alternate version of each lesson plan.

The parent comment captures the education system’s attitude toward teachers perfectly. The problem is always due to a shortcoming of the teacher, and the solution is always the responsibility of the teacher.

I’m baffled by this. My wife worked at a charter school and it was nothing like this. The teachers were constantly trying to get certain kids out of their classroom who were actively threatening staff and other students, and the administration would never do anything. The assumption being that losing a kid would hurt numbers and impact funding.

I’ve only ever heard of TDD in the context of greenfield development. I thought the whole point of TDD as opposed to just “writing a lot of tests” is that you write the tests first, and that more or less determines the design of the system? TDD looks at tests not just as a cost center that pays off on the future, but as a tool to help you design stuff right now.

This is my perception as a non-TDD person. Maybe someone can validate if this makes sense or not.

This was my experience too. IIRC they raytrace the lightmaps for the whole map on demand during loading instead of baking them ahead of time. But I might be misremembering

Only 10 files? Must be nice!

This line at the end of the article triggered me:

> You can invest [your spare time] each week towards something bigger like a pub/sub system so that you can pull a new microservice out of your monolith.

The article linked in the grandparent directly explains how utility classes are different from inline styles: there are infinitely many possibilities with inline styles; not so with utility classes. The empirical numbers in the article are fascinating. 400+ different colors in a single CSS project that’s supposed to be “semantic”. With utility classes, you are forced to choose from a finite set of colors.

I think this might be one of those “difficulty curve” memes. On the left, the Padawan: “just use UTC timestamps”. In the center, the journeyman: “no!!! we have to store time zones and translate between them! Time zone awareness!” On the right, the Jedi master: “just use UTC timestamps”.

I share your concerns, but you can store passkeys in the password manager of your choice, which syncs them across all your devices. As long as device attestation remains optional (and that's a big if), passkeys are strictly better than passwords.

It’s so disingenuous for them to say “early cancellation fees are less than one percent of revenue, they don’t affect our business.” Of course it’s a tiny chunk of revenue, because no one is canceling! That’s the whole point of the fee!

> Future models will not be able to do those things if they are the same as the current ones

I think a lot of people disagree with this. People think if we just keep adding parameters and data, magic will happen. That’s kind of what happened with ChatGPT after all.

We all lost our minds when Google tried to pull their privacy-preserving Federated Learning of Cohorts thing. I expect an even bigger outcry when Firefox, whose entire brand and reason for existence is privacy, quietly tries to do the same thing.

The later videos are like cautionary tales… 5 years in, no game in sight, and you’re 30 videos deep into writing a sophisticated global illumination system…

If we’re talking Jekyll, I completely agree with this post. But Hugo is a single binary that runs on practically anything. And it does stuff that would be a huge pain otherwise, like generating responsive image sets.

Ah right, I remember I ended up writing a netplan YAML. I still couldn’t get it to persist across reboots, and just resorted to running “sudo netplan apply” every time it rebooted.

To be fair, I still have no idea how to set the DNS server on an Ubuntu server in a way that won’t get wiped out on reboot. Is it resolv.conf? Nope, that’s generated by another tool. systemd-resolve? I think that’s getting closer… network manager? By the time I figure it out they’ll add another one to the pile.

I wasn’t too worried about the spiderbot legs since they had no impact on gameplay. The bots originally had four legs. Over time, triangles became a major part of the visual motif of the game, so I slowly changed all the squares to triangles and everything had to come in threes.

Hi, author here. Sadly, I had to cancel it. The source code is here: https://github.com/etodd/lasercrabs (I briefly tried to rebrand and release it as-is). The story is here: https://etodd.io/2023/06/27/making-games/

I remember that post, thanks for sharing!

Probably half of my posts that hit the front page got there via the second chance pool. It feels like dang is single-handedly turning back the tides of the internet by hand-picking links.

The best part is the very end, where it is revealed that the study was done by two dentists.

Wow that’s incredible. What a sentence too. Slides right through your brain without any meaning getting caught on it.

Wow I’ve been thinking of something exactly like this! Sort of a super charged, statically typed version of Go’s context.Context. It would allow you to describe the capabilities (or effects) of every function, including IO, memory allocation, cancellation, deadlines, concurrency, and whatever application-specific stuff you need on there (like logging).

Then you could implement something like Google capslock [0] just by looking at type signatures.

0. https://github.com/google/capslock

What’s the story with threading on the web these days? My impression was that the browsers have purposely and permanently handicapped some things necessary for performance in order to prevent things like rowhammer and speculative execution exploits. But I haven’t paid super close attention.

A golang library that uses the Docker SDK to create and run containers.

My version is more opinionated than testcontainers and can really only be used inside Go tests (relies on a testing.TB)

I looked at testcontainers and ended up rolling my own version. One issue I had is that Docker is a very leaky abstraction. I needed to write one test and have it run in all these scenarios:

- on a Mac

- on a Linux VM

- in a Docker container on a Linux VM, with a Docker socket mounted

The networking for each of these is completely different. I had to make some opinionated choices to get code that could run in all cases. And running inside Docker prevented the test from being able to mount arbitrary files into the test containers, which turns out to be a requirement often. I ended up writing code to build a new image for each container, using ADD to inject files.

I also wanted all the tests to run in parallel and spit out readable logs from every container (properly associated with the correct test).

Not sure if any of these things have changed in testcontainers since I last looked, but these are the things I ran into. It took maybe a month of off and on tweaking, contrary to some people here claiming it can be done in an hour. As always, the devil is in the details.

edit: I did end up stealing ryuk. That thing can’t really be improved upon.

The problem with JIRA and its ilk is that they try to do bug tracking, planning, and historical data all in the same tool, when those are really separate problems.

Have a bug? JIRA makes perfect sense, you have a ticket with comments, it keeps track of how long it's been around, it can automatically move the bug through a process, etc. All these tools started out as "bug trackers" after all.

Trying to plan future work? What I usually want is some kind of lightweight graph tool to figure out task A unblocks task B, etc. This graph changes a lot over time, with tasks merging and splitting apart. I've wasted a lot of time trying to enter all this in tickets.

Want to know about work that's already completed? I would never look at JIRA. Look at your Git forge. Pull requests should have proper descriptions. The Git history will always be more accurate and detailed than a bunch of JIRA cards.

So basically, use JIRA for bug tracking, Git/Github/Gitlab for historical tracking, and I'm not sure what to use for planning. Honestly I've been reaching for Excalidraw recently.

Interesting, I’m in the middle of a huge project to move us AWAY from compiling a separate binary for each environment. In our case, I don’t see how hardcoding config values can play nice with infrastructure as code tools, or the need to offer an on-premises version of the app.