myrmepropagandist
Just got a card from a student who has been having a rough year. She was having a great deal of trouble until I started showing her how to really USE a calculator. (It's algebra and geometry not arithmetic, and she knows the algorithms just makes SO MANY little mistakes)
Since then she's really taken off. I find very few people who could benefit from calculators know how to use them effectively, and there is a lot of snootiness and stigma in the way of this happening.
1/
myrmepropagandist
I've heard teachers complain "my students put things like 6*8 in the calculator"
I always think "so?" I mean if they know it's around 50 and are worried they've mixed it up with some other fact why does it matter?
You are teaching calculus who cares?
(It's 4 ... 12s which is helpful if you know the 12s but if you didn't learn them young... anyway it's kind of a distraction from the problem at hand. Get the correct result. Use the tool. )
SnackTraces
@futurebird
Loving all of this post!
You have planted a seed. You have increased the chances of her liking math. And if she likes math, she increases the number of career paths she can take.
It is one of things I sort of get bummed out about is that schools (in general) do not teach how to use tools. Tools that are widely used in industry.
You rock!
myrmepropagandist
I generally agree that up to around grade 7 there isn't much use for calculators. But from there out if you understand place value and can estimate being consistent and accurate doing long hand calculations is kind of overrated-- I'm always a little shocked that once I tell the grade 9 students they can use calculators they somehow keep making arithmetic errors... (HOW) not this student, though!
She might even like math now. Imagine that.
2/2
Paul Cantrell
@futurebird @snacktraces
Yes! Normalize redundancy, verification, and checking external sources, instead of encouraging the arrogant practice of refusing help to demonstrate knowledge! It’s a fragile ego that refuses “measure twice, cut once.”
Paul Cantrell
@stacey_campbell @futurebird @snacktraces Joe Groff (of the Swift compiler team at Apple, wow do I miss him on here) once remarked that unit tests and static types have in common that they are a form of •systematized redundancy•: both ask engineers to express their understanding / assumption / intent in two forms, and then a second actor (the machine in both those cases) checks that the two forms agree. I love that way of seeing it.
Stacey Campbell
@inthehands @futurebird @snacktraces Great advice.
Recently my son had CS coursework that involved converting a bowl-of-spaghetti logic diagram into a C++ program. Me, with 40 years of C experience, independently wrote my version of the program, he wrote his in C++. I asked him to send me his output and I sent him mine.
They didn't match, and sure enough I had messed up an AND gate.
Paul Cantrell
@futurebird @WizardOfDocs @snacktraces Yup! And there’s a second very pernicious consequence, one that materializes later, of not having practice looking up existing solutions and working with other people’s code: sometimes it’s a solved problem and the existing solution is •wrong•, or right but not for your problem, or could use improvement. You’ll only see that clearly if you’re used to engaging with code as •conversation• instead of some kind of intelligence test.
myrmepropagandist
@WizardOfDocs @inthehands @snacktraces
It's a solved problem! Don't solve it again!
Alex, the Hearth Fire
@inthehands @futurebird @snacktraces this is a thing I had to learn the hard way in undergrad computer science
I'd come from a liberal arts background where looking up the answers was cheating
I still feel bad using other people's code, even though I hate programming, because everybody's going to know I don't understand what I'm doing.
When the truth is that being able to synthesize other people's code to do what you want is how you prove you do know what you're doing.
Paul Cantrell
@futurebird @WizardOfDocs @snacktraces I tend to think this way of engaging with code — “Does this existing code work? What does it do? What problem is it solving? Is that •my problem?” — is already crucial, and on a trajectory to become 10x more so. We CS educators need to get better at teaching it it. Now. Yesterday.
It’s already a problem finding answers on Stack Overflow. And in the coming onslaught of plausible-looking LLM-generated bullshit code? Well…
Paul Cantrell
@steve @stacey_campbell @futurebird @snacktraces But I’m lazy, I want •him• to come to •me•
…In seriousness, though, has somebody built a Cohost→ActivityPub bridge, even if only one way? Seems like that ought to be possible, but a quick search doesn’t turn it up.
Steve Canon
@inthehands @stacey_campbell @futurebird @snacktraces Joe’s active on cohost, fwiw
Paul Cantrell
@jepyang @futurebird @WizardOfDocs @snacktraces Hardly even fiction!
jnpegay
@inthehands @futurebird @WizardOfDocs @snacktraces One of my favorite sci-fi concepts of all-time is the Qeng Ho programmer-archaeologists from Vinge’s Deepness in the Sky
Paul Cantrell
@datarama @futurebird @WizardOfDocs @snacktraces Yeah, that’s good stuff. I’ve managed to get at least a little bit of design-by-contract thinking into our 2nd semester course, although I’m not sure it sticks (yet, still working on it!).
Speaking with my industry hat on, there’s a limit to how much that kind of formalism can help. Intent and purpose are usually squishy, ambiguous, full of hidden assumptions… 1/2
Paul Cantrell
@datarama @futurebird @WizardOfDocs @snacktraces …and while formalizing them often teases out those hidden assumptions, just as often it can lead engineers to diligently verify and implement •the wrong goal•. That’s why it’s crucial to pair that sort of proof-flavored thinking with the skills of the humanities: communication, theory of mind, trust-building, etc. One without the other faceplants fast.
(This is where Paul recommends Lakatos’s Proofs and Refutations)
Paul Cantrell
@WizardOfDocs @datarama @futurebird @snacktraces I should learn more about pragmatics!
Ironically, the tools of linguistics (particularly grammars and form semantics) turned out to be much more useful for programming languages than for natural languages. Fighting words, maybe, but I think that’s true.
Alex, the Hearth Fire
@inthehands @datarama @futurebird @snacktraces yeah, formal semantics is my least favorite part of linguistics. That's why my master's thesis is in pragmatics: it lets you study speaker intent *without* all those assumptions.
Paul Cantrell
@WizardOfDocs Don’t worry, you’re coming through perfectly clearly!
Alex, the Hearth Fire
@inthehands @datarama @futurebird @snacktraces (sorry if that doesn't make sense, I'm waiting on new glasses and I'm not thinking as clearly while I can't see clearly. What I mean is semantics focuses too much on the literal informational content of language, while pragmatics gets into all the reasons people say things the ways they do, which I think aligns better with what y'all are advocating for.)
Paul Cantrell
@finestructure Yes. I’ve noticed again and again, in multiple directions, that developers dislike unfamiliar p-langs / tools because they bring all their old assumptions and habits with them. “How can I do [practice I’m accustomed to] with [tool designed around different practice]?!? This sucks!!”
Tools have ecosystems, which encompasses both tech things and human things. They only make sense in their natural habitat.
Sven A. Schmidt
@inthehands That nicely generalises an observation I once made when switching backend dev from Python to Swift: a lot of my usual Python unit tests fell away because they were essentially type checks in data processing pipelines.
Paul Cantrell
@finestructure Used to Swift, freaked out by no static types in Python? You can still write great software, but your relationship with unit tests is going to change!
Used to Python, think Ruby syntax is too weird, too full of hidden magic? Your relationship with readability is going to change; aim for domain-specific idioms, not universally recognizable lego pieces.
Used to Ruby, angry at Swift’s type strictness? Change your design process to lean on the type system.
Paul Cantrell
@datarama Chef’s kiss.
Paul Cantrell
@datarama Yup yup.
I am a broken record: Proofs and Refutations, by Imre Lakatos. Great book. If you haven’t read it yet, do. You won’t regret it.
Paul Cantrell
@datarama Ah, then I see I am preaching to the choir!
Paul Cantrell
@paddlefish Maybe counter, maybe just pushes it back a few layers. At best, it lets the developer push those explicitly stated assumptions back to the places where they’re actually worth stating (as opposed to “yes, I explicitly think that int plus int is int). At worst, they turn code into a Sudoku-like logic puzzle of a build error.
Andy Rahn
@inthehands @stacey_campbell @futurebird @snacktraces so type inference is counter to that. Which is useful to say out loud when wrestling with type inference gone awry, as often happens when chaining many function calls together
Paul Cantrell
@dahukanna @paddlefish
Runtime type creation and static verification are always in tension. Anyone who tries to pretend there’s no tradeoff there is too much inside their own bubble.
Dawn Ahukanna
Case in Point - I “melted” UI developers minds who insist on TypeScript for coded static type checking by extending/mutating said types in running JavaScript browser code to demonstrate prototype-based inheritance.
Unspoken assumptions should really be replaced with stated presumptions with %age of occurrence in a specific context and time range. Useful friction, overcome by required potential energy.
Paul Cantrell
@dahukanna @paddlefish Exactly!! Seeing tradeoffs is the heart of engineering. Yet somehow our human nature always makes us want a single best answer for everything….
Dawn Ahukanna
> “Runtime type creation and static verification are always in tension.”
Nicely said. How does this get missed and ignored?
Paul Cantrell
@dahukanna @paddlefish It’s a lonely world for people like us, Dawn.
Dawn Ahukanna
Every situation is on a spectrum i.e. has more than one value & I’ve never understood the need to have to have “the contextless only one”.
Benjohn
@futurebird @snacktraces @stacey_campbell @inthehands a great dev I worked with made the analogy with accountancy’s “double book keeping”.
Paul Cantrell
@benjohn @futurebird @snacktraces @stacey_campbell That is spot on.
Paul Cantrell
@ragectl @finestructure I wouldn’t go that far: type annotations in Python •can• be good documentation, •can• help autocomplete, •can• help developers think clearly — but certainly the tradeoff calculus changes. The questions, as always, are: What problem does this solve? What’s the cost? What’s the benefit? What’s the answer to these questions •as we actually use• the tool, not just in the wishful abstract?
ragectl
@finestructure @inthehands I was watching some videos on Python and Rust, and they both had the same message about data types.
One said not to bother with type hints in Python because that wasn't the point of writing in Python to begin with
Paul Cantrell
@maxd @finestructure Indeed, user-visible errors are frustrating to users! The question is whether static type checking meaningfully reduces user-visible errors in the same dev budget/timeframe, and empirical results on that are stubbornly inconclusive (and not for lack of research trying to get a solid answer!). The treadeoffs mostly remain exactly as you said in your post: an opinion. (I say this as a great fan of static types!)
Max Desiatov
@inthehands @finestructure IMO type safety is as important as memory safety is. Type errors in dynamic languages exposed to users are just as bad as memory corruption bugs. Non-technical users really wouldn't see a difference between "core dumped" and "undefined is not an object", and the end result is the same: frustration.
Helge Heß
@inthehands @maxd @finestructure This is a really good one on static typing, in case someone didn't read it yet: https://blog.metaobject.com/2014/06/the-safyness-of-static-typing.html
Paul Cantrell
@helge @maxd @finestructure Yeah, many of the bits of research I was referring to with “empirical results on that are stubbornly inconclusive” are referenced there. There’s also research that claims to find empirical evidence benefit for static types, mostly in bug prevention. But if the case is clear for anyone, that’s taste at work, not evidence.
Helge Heß
@inthehands @maxd @finestructure Which is also very similar with tests.
Paul Cantrell
@helge @maxd @finestructure To the point of my OP, I tend to think these strong opinions — and research, for that matter — go astray from the start with the question of “Which is better?” The more interesting questions have to do with how development habits, practice, culture, ecosystem, etc. evolve around tools with a particular shape. We make the tools work. How do they make •us• work?
ragectl
@inthehands @finestructure the comments in the videos were just in agreement with the idea that if your tests are only really trying to validate data types, you should be looking to move that code to a statically typed language. In context, the videos were talking about how python frameworks wrap C/C++/Rust code for the speed of core functions.
mary beth ☑️
@futurebird In my Ed Psych class that all future educators had to take, I was literally *told* that knowledge of subject matter was completely irrelevant to effective teaching; I refused to believe it, because elementary and middle school teachers can encourage their students to explore/experiment/discover mathematical meaning if the teachers themselves understand connections between the physical world and the mathematical objects that we use to make sense of reality around us
the roamer
Subject mastery gives pedagogical freedom, doesn't it. The ineffective teacher obsesses with meeting the syllabus, precisely because they fail to fully understand the subject matter in its foundations. They use didactics to hide the superficiality of their content. The effective teacher is free to focus on student learning, precisely because they are able to provide natural links to the subject matter, in spontaneous response to the student's trials and mistakes.
myrmepropagandist
@dendari @notsoloud @the_roamer @maryErudis
I'm horrified when k-7 teachers say "I hate math it's impossible" or "calculus never made any sense to me"
It's bad that you had a bad experience with math... but we gotta DO SOMETHING about those feelings. Even if you never say it those ideas are transmitted to students.
I'd love to teach a calculus or linear algebra course for k-7 teachers ... provided they were being compensated for the time sink. I think it would make a big difference.
Dendari
@notsoloud @the_roamer @maryErudis @futurebird
The issue mostly seems to be elementary teachers who don't feel comfortable with math and are reluctant to explore outside the prescribed curriculum, afraid to make mistakes.
notsoloud
@the_roamer
I believe that a teacher ought to have an understanding of the subject two levels above that of the student:
The first level so they have something to teach.
The second level so they can teach in a way that builds a suitable foundation for future growth.
If they're not two levels above they should seek advice from someone who is.
Merrill Holt
@mybarkingdogs @futurebird There are several things you need to make math fun. A good calculator helps. You can get an excellent Casio for a bit over $20. Don’t get a graphing one. Next learn to use a computer graphing app. My current favorite is desmos.com. Next is learning to use a symbolic calculation app. A really good one is symbolab.com. These are both online. The next is good math books. You can get used textbooks that are inexpensive since you don’t need the most recent editions. A really nice series is by Elayn Martin-Gay. Have fun.
mybarkingdogs
@futurebird I've actually been reconsidering trying to learn math, despite having dyscalculia, outside of formal ed because there's a lot of stuff I'd like to learn, but I never, *ever* want to learn with stakes or to make sure I pass a test again
and being able to use memory aids, to go back and read how to do stuff over again, to *not have to remember everything in my head* and calculators is one reason why I'm even considering
GNU social JP is a social network, courtesy of GNU social JP管理人. It runs on GNU social, version 2.0.2-dev, available under the GNU Affero General Public License.
All GNU social JP content and data are available under the Creative Commons Attribution 3.0 license.