> What a lot of math learners fail to understand is that grinding through concrete examples imbues you with intuition that you will not get if you jump directly to studying the most abstract ideas.
I feel that's more a lesson for a lot of math teachers to understand. I remember some frustrating linear algebra, calculus and computational complexity courses where the lector basically threw some formulas onto the blackboard, went line-by-line through a formal proof of their correctness and then called it a day. Giving actual examples of the application of the formula was an afterthought left to the student aides. Giving examples that could explain the derivation of the formula was not even considered as an idea.
It always reminded me of someone teaching an "introduction to vi" course but then just scrolling through vi's source code without any further explanation - and in the end expecting the students to be able to fluently use vi.
> > What a lot of math learners fail to understand is that grinding through concrete examples imbues you with intuition that you will not get if you jump directly to studying the most abstract ideas.
> I feel that's more a lesson for a lot of math teachers to understand.
That's certainly true, but the teachers who teach that way were probably once students who tried to learn that way (I was one on both counts, though I got better), and it'll be better for them as teachers if they learn the lesson as students.
Adding, not disagreeing, but at some point, those abstract concepts like dot products become concrete on their own when you get into things like SIMD programming.
Yeah, but to arrive at that point, you'd have to have understood dot products already.
It's one thing to take two float arrays, multiply them componentwise and sum the results. It's another thing to understand why this operation constitutes the dot product in R^n vector spaces.
Does it matter whether the professor or the teaching assistant is the one giving the examples?
The professor is in an awkward position, because the professor at the front of of the large-group lecture hall doesn't have anything to do to add value. Watch videos, read book, work exercise, and then go to recitation or office hourse for interactive tutoring.
Yeah. It's kind of ironic given how unhappy the author sounds about people being unable to figure out what's going on after seeing the same thing over and over again.
That's the same principle which makes it wise to first do some copy pasting before you abstract stuff into a common library. Gathering some (more than two) concrete use cases before you factor out the common functionality makes much better library functions.
A common sign of prematurely deduplicated code is a common function with lots of boolean flags and other knobs to tweak its behaviour for every use case added after it was written.
You owe it to yourself to type out your copied code again. So easy to lose track of context when you’re moving fast. Variables have the wrong name, conditionals can’t be false, etc. Copy, yes, but don’t paste. Do it the hard way.
The ideal heuristic is to only deduplicate towards more orthogonality.
Suppose you started from first principles and navigated down the ontology tree taking one of the shortest paths (well, shortest-ish since it's a hard problem that'll burn up too much time otherwise.) Would you encounter your deduplicated function on the way? If not, it's making it worse.
I was on a team rewriting a UI from native to web, so we were moving fast on copying existing features instead of inventing new ones. About four times in 18 months we had triplets of features in the backlog and tried to generalize the implementation on the second occurrence, only to have to do expensive rework on the third. The code and the tests just wouldn’t bend the right way. We had mostly agreed to follow the Rule of 3 but someone kept thinking this time would be different and it never was. The last story was always the slowest and extra time spent on the middle one was wasted.
'rule of 3s' is way too simplistic. It is on the beginner level. 3 is an arbitrary number anyway. It can be any other number depending on the situation. And creating an abstraction from only one use can be valid. In particular this happens if something gets a bit big while talking to too many other things. E.g., a function receives RPC while also doing something with a piece of hardware, and both of these things are a bit non-trivial. These two things should then not be mixed even when it is the only function doing these two things. I will say though, that creating an abstraction from one example one should expect that some future improvements to the abstraction will most likely be necessary.
This is presumably about math problems, but I always approach programming problems this way.
One issue I have with math problems is that sometimes I wish I could immediately go down one level of abstraction and see something like a physics or programming problem that applies that specific or related problem I'm working on. I haven't found a resource like this yet.
Not a guide, per se, but it has many implementations of a wide variety of math and programming concepts, implemented in a large number of different programming languages.
This is cool. It's pretty close to what I meant, but each task is completely siloed without any meta information, so it's good if you wanted to look for something very specific but not good if you are thinking about or exploring a problem space.... For example, on the page for factorial it might be nice if they linked to other kinds of combinatorial problems.
Although I bet that ChatGPT might already know a lot of this kind of thing. I haven't had the chance to use LLMs in this specific context yet.
And why is it so hard to have math education based on good concrete contextualized examples, vs just rules and problem sets? Understanding the “why” behind the math is often lacking… and math doesn’t always need to be applied, that’s ok— but if it can be, it is so much easier to understand
This was something that really lacked in my statistics degree. We were always learning different distributions, proofs and estimation methods but very rarely applied them to actual problems. I feel like you can kinda get away with this type of thing in math more, but in statistics, it makes things super hard to learn.
I kinda wish you could just take a course on a specific distribution. Like, here's the Poisson class where you learn all of its interesting properties and apply it to e.g. queuing problems.
I took a lot of stats and probability courses in university, but never developed any intuition related to it. This would have been very helpful to me back then and now even.
I’m adopting an Example Driven Development approach in my latest project. The project is a library/framework with a public interface. EDD is great in this case. To explore and experiment new features, I turn the use cases into runnable examples and use those to drive the internal implementation. This combines feature implementation, documentation, examples, and testing in one shot.
Yes, exactly. See [0] for a concrete example of an abstraction that can't be grokked without grinding concrete examples, and how people who have already grokked it forget this fact.
A concept I learned about in Knowledge Based AI (gatech ONSCS) is called “version spaces” where instead of starting at specific examples and moving to be more general or the other way around you do both as a kind of knowledge bidirectional search. I feel humans work that way too. We need both specific examples and generic models to help us converge to a deeper understanding of topics.
But on the other hand, 2 or 3 elements of the sum are usually enough, i.e. you probably wouldn't improve understanding by writing out the first 10 elements or so.
Readit News
I feel that's more a lesson for a lot of math teachers to understand. I remember some frustrating linear algebra, calculus and computational complexity courses where the lector basically threw some formulas onto the blackboard, went line-by-line through a formal proof of their correctness and then called it a day. Giving actual examples of the application of the formula was an afterthought left to the student aides. Giving examples that could explain the derivation of the formula was not even considered as an idea.
It always reminded me of someone teaching an "introduction to vi" course but then just scrolling through vi's source code without any further explanation - and in the end expecting the students to be able to fluently use vi.
> I feel that's more a lesson for a lot of math teachers to understand.
That's certainly true, but the teachers who teach that way were probably once students who tried to learn that way (I was one on both counts, though I got better), and it'll be better for them as teachers if they learn the lesson as students.
It's one thing to take two float arrays, multiply them componentwise and sum the results. It's another thing to understand why this operation constitutes the dot product in R^n vector spaces.
The professor is in an awkward position, because the professor at the front of of the large-group lecture hall doesn't have anything to do to add value. Watch videos, read book, work exercise, and then go to recitation or office hourse for interactive tutoring.
A common sign of prematurely deduplicated code is a common function with lots of boolean flags and other knobs to tweak its behaviour for every use case added after it was written.
Suppose you started from first principles and navigated down the ontology tree taking one of the shortest paths (well, shortest-ish since it's a hard problem that'll burn up too much time otherwise.) Would you encounter your deduplicated function on the way? If not, it's making it worse.
One issue I have with math problems is that sometimes I wish I could immediately go down one level of abstraction and see something like a physics or programming problem that applies that specific or related problem I'm working on. I haven't found a resource like this yet.
https://rosettacode.org/wiki/Rosetta_Code
Not a guide, per se, but it has many implementations of a wide variety of math and programming concepts, implemented in a large number of different programming languages.
Although I bet that ChatGPT might already know a lot of this kind of thing. I haven't had the chance to use LLMs in this specific context yet.
Deleted Comment
And why is it so hard to have math education based on good concrete contextualized examples, vs just rules and problem sets? Understanding the “why” behind the math is often lacking… and math doesn’t always need to be applied, that’s ok— but if it can be, it is so much easier to understand
So, now instead of one concept you have two unfamiliar concepts--one of which is far removed from your pedagogy.
It sucks, but there just aren't that many straightforward applications of abstract math classes.
[0]: https://byorgey.wordpress.com/2009/01/12/abstraction-intuiti...
But on the other hand, 2 or 3 elements of the sum are usually enough, i.e. you probably wouldn't improve understanding by writing out the first 10 elements or so.
You need:
and you'd like: where the stuff in *italics* is given as a concrete substitution.