Hacker News
Hachi: An Image Search Engine
The CRDT Dictionary: A Field Guide to Conflict-Free Replicated Data Types
Fabric Project
Bringing Sexy Back. Internet surveillance has killed eroticism
So you wanna build a local RAG?
Replacing My Window Manager with Google Chrome
Building road signs at home using a Cricut Machine
WebR – R in the Browser
X / Twitter
So glad Math Academy is working out for your kid! We're looking forward to extending our system down to earlier levels of math so more kids can join earlier.
In the meantime, I'll go through some general failure modes to watch out for.
(Haven't looked closely enough to weigh in on resources for very early math, but hopefully these failure modes will assist in avoiding ineffective ones.)
== Failure Mode 1 ==
Staying in "block/finger-counting" land so long that the the manipulatives become a crutch. The kid gets so comfortable and attached to the manipulatives that they resist moving on.
(@ninja_maths has a nice write-up here: https://t.co/Jg6rBRPWjp)
== Failure Mode 2 ==
Covering a bunch of special-case arithmetic strategies instead of getting the kid really solid on the standard algorithms.
When the kid is first learning this stuff
-- they can get overwhelmed and paralyzed with "what strategy do I use,"
-- they can latch onto their favorite strategies and try to use them for everything even though they only work efficiently in special cases, and
-- they might not even realize that the standard algorithm is general-purpose (they may just think "whatever, that's another strategy, I already have one I like").
== Failure Mode 3 ==
Avoiding memorization. Once a kid is able to compute arithmetic facts, they need to work on developing automaticity via instant recall practice.
If they don't develop automaticity on their math facts, then it creates a lot of friction later on. Things that should be quick & easy, like computing exponents and enumerating factor pairs, become really hard & time-consuming & error-prone when a student doesn't have their times tables memorized.
(I wrote more about this here: https://t.co/Okjg6sR3uh)
== Failure Mode 4 ==
Serving up too many easy facts during times tables practice.
It's a problem that plagues many, many times tables practice systems: when your practice is randomized across the entire times table, or even if you limit it to a longitudinal or lateral subset (e.g., “just facts involving 7 and 8”), you end up serving up way too many easy facts.
In a 12x12 times table including 0, over a third of the facts involve 0, 1, or 2. Over 70% of the facts involve a small number (0, 1, 2, 3, 4, 5).
So if you say that the student needs to answer some number of facts correctly in some amount of time, maybe even subject to a loose accuracy threshold, and you choose these facts randomly across the table, or even if you limit to a longitudinal or lateral subset later in the table… you’re still going to be serving up a crap-ton of easy facts and the student could quite easily “pass” your success criterion by nailing the easy facts while struggling on facts that are even just moderately challenging.
The way around this is to be very careful about what subsets of the table you’re practicing on, and very careful about how you select questions to test the student on. In particular:
-- After the student learns the easy facts, they need to quizzed on subsets of the table containing harder facts and leaving out easy facts.
-- Each individual question must be timed. If a student doesn't respond quickly enough, they miss the question. (Of course, this timed retrieval practice should come AFTER the student is able to compute results untimed.)
-- And if they ever miss a question, it needs to come up again (spaced out with some other questions in between) and they have to get it right.
Basically, you need to go Terminator-mode on the times tables, hunt down what facts the student doesn't know cold, serve them to the student, and force the student to learn them. You can't let the student "get by" on an aggregate metric despite not knowing some facts.
It’s not good enough for a student to know the easiest 80% of facts in the table. They need to know 100% of the facts and their practice always needs to be targeted to the facts on which they are the shakiest (while, of course, scaffolding up to harder facts by first covering any easier “prerequisite” facts that the student hasn’t yet learned).
==
Anyway, those are the 4 biggest failure modes that came to my mind just now but I'm sure there are more that I'm not thinking about. If anyone reading this wants to continue the list and/or offer resource recommendations that avoid these failure modes, please feel free!
Don’t make me tap the @patio11 sign
https://t.co/jKUpaGUG9D https://t.co/LQrWFjqYZc
Bloom studied the training backgrounds of 120 world-class talented individuals across 6 talent domains: piano, sculpting, swimming, tennis, math, & neurology. And what he discovered was that talent development occurs through a similar general process, no matter what domain. https://t.co/xwGVwcCZAA
Check out the overview and grab the file:
https://t.co/YjOBWpMPEB
I was asked by my CEO to write some advice for a new hire on being proactive and working autonomously, and though I'd drop it here in case it might help someone:
When you make a feature, you have to think about it holistically- understand where the data is coming from, how fast it should be (especially on the UX side), what the data formats look like, what errors might pop up, what the risks are (and how to test for/mitigate them), and most importantly the UI/UX.
There's a fine line between being stuck and being independent. Generally my rule of thumb is that if I'm stuck on something like a package issue for more than 30m, I'll ask the team as we have collectively seen most of the possible package issues and know how to resolve them. For something like UI design or architecture I'll typically take my best first try at it then loop in someone like N/V to make comments as UI design is my weak spot (but these guys are amazing at it)
When you work here you are no longer just a SWE. One day you might be making a new feature like this ticket, the next you might be designing a new landing page and writing copy, the next you're optimizing the database with psql, and the next you're using posthog to transform our data into actionable product insights. You're essentially SWE/design/PM/DBA on any given day- which can be a little overwhelming at first (I felt this during my work trial) but once you adjust a bit there's no feeling more fulfilling than knowing you can handle whatever is thrown at you.
We are all (mostly) usually available for discussions or questions about architecture, why something was made in a certain way, or how to do something. We move incredibly fast here which you will see. This means a couple things:
1. If you see something that you think may have been done wrong or non-optimally, PLEASE PLEASE PLEASE bring it up with us. This happens all the time, it's not mean or demeaning to anyone. We have all made stupid mistakes and occasionally taken down prod. We are always trying to improve our app, and small fixes can sometimes cut something down from 300ms to sub-50ms which is noticeable at the UX layer, which means our users are happier which is always our main goal.
2. Things are always changing and it's hard to keep up with sometimes. Reading through linear issues helps, and we try to write documentation for big changes which looks like this [redacted] so that everyone can have a quick high-level overview of how things work. We don't always do this though so if you need to understand something the fastest way I've found is to ask Claude code 4.5 opus for a high-level overview -> read the code myself -> call/text someone if confused about anything.
Most important: Don't stress about doing amazing in the work trial. We don't expect you to be an expert in anything. We mainly want to see how you work and how you tackle working with technologies you may not be familiar with. During my work trial I had to implement collaboration features in PostgreSQL. I had never worked with any real postgres code besides making tables before this, and had to learn pretty much on the fly with o3 and claude code. I ran like 20 different migrations, brought down prod twice, and eventually got it done (and got the offer). We mainly want to see that you're able to work/learn quickly and autonomously, which will always come with making mistakes.
I realize I mention mistakes a couple times here — never do something that's irreversible and you'll be fine ;)
accidentally discovered the website for Departure Mono, made by the makers of Phosphor Icons. what a beauty🧡 https://t.co/F6t20soWOY