Thread by @ManishEarth

a recent conversation amongst friends reminded me of my thoughts on expertise, magic, and mental models, and while this probably should be a blog post I'm lazy so I might as well thread it

the context of this was advanced borrow checking in rust, but most of the thoughts are more general and apply to a lot of learning paths, at least in programming

for example, with lifetime elision / explicit lifetimes in rust, i've heard the learning process described as:

1. Beginners: Rely on the "magic" (elision), and use it exclusively. They're lost the moment they need to step out of it, until they learn the underlying workings.

2. Intermediate: Understand most of the workings of explicit lifetimes, but perhaps not enough to keep the magic in their heads. Tend to map the magic to the underlying model and rely on the magic less, using more explicit lifetimes, etc

3. Expert: Understand the entire system enough to revert to using the magic as much as possible. Can totally use the advanced stuff, but will avoid it unless it's necessary.

This was just an example but I've seen this kind of thing play out for various different topics in computing. There's some magic, the beginners rely on it, intermediate folks are able to work outside of the magic but they use the magic less, experts use more magic again

"magic" here is, essentially, some imperfect abstraction layer. it's imperfect because sooner or later you have to care about it. It's a great benefit to the learning process, and overall makes things easier, but it also introduces this u-shaped curve of "how much you use it"

the underlying driving force here, the underlying driving force in a lot of learning processes, is mental models. Specifically, the process of working through *inaccurate* mental models, which are often easy and natural to construct.

I've talked about this before in manishearth.github.io/blog/2017/04/0… (There I call them "bad" mental models, using scare quotes, but I now prefer to avoid the implicit value judgement as much as possible)

A lot of the problems faced whilst learning a subject are due to having a mental model which is an inaccurate (not just incomplete!) depiction of the real world. This leads people down the wrong path at times, leading to frustration when things do not work the way they expect

It's *very easy* to build inaccurate mental models. You implicitly build a hypothesis of how the world works, and notice that your hypothesis "seems to work", and kinda cement it in your mind without relitigating it as you learn.

As I say in the blog post, this tells us that we should approach such situations with empathy, not derision, but there's more: this helps us better map a lot of learning processes

For example, the beginner/intermediate/expert curve I explained before?

The beginners have an inaccurate mental model from the imperfect abstraction layer. This is *okay*, the abstraction layer still helps them learn piecemeal.

The intermediate users have realized their mental model was inaccurate and have moved away from it, sometimes unnecessarily avoiding the abstraction layer.

The experts' mental model includes the abstraction layer and they're back to being comfy with it.

The whole contour of the learning process is dictated by what mental models you build, when they turn out to be insufficient, when you notice that, and how you update them when so

A good teacher is, among other things, able to notice when the mental model is inaccurate, and when it's necessary to fix that, and help fix it.

An experienced individual (or good autodidact) is able to, on their own, notice quickly when their mental model needs to be updated, and appropriately work on updating it.

maybe it's because i'm an autodidact, but to me this^ has been the singular *technical* thing that I consider to be core to "expertise in programming". There are things like "working with others" that are important too, but this is the only one related directly to technical skill

Not the number of programming languages one knows, not the quality of ones preferred tools, it's one's ability to learn and adjust their mental models when necessary. This unlocks so much else.

ah, for the life of me I couldn't remember where I'd gotten the borrow checking example from, after @samth pointed it out I remembered: it's building on Terry Tao's "phases of rigor in math" post. I suspect I'd come up with it after reading this ages ago terrytao.wordpress.com/career-advice/…

it covers a lot of this better than I do, go read it

@plaidfinch has an excellent way of phrasing the core principle in this thread:

https://twitter.com/plaidfinch/status/1366603813893849089