A Programmer’s Regret: Neglecting Math at University

A long time ago I gave up the "manager track" and went back to be an individual contributor mostly because i noticed I was having to look up things I "ought" to have known

Slowly now I am settling into the idea (the confidence) that I am actually pretty good at this, and that occasionally looking up how to open a csv file is just an artifact of knowing why and what if not precisely how

(it's also a good indication that another abstraction that is easier to remember might be useful)

I’ve spent the last few months immersed in modern C++ after mainly doing C# at my job over the last few years. I opened up a C# REPL (can’t recall why exactly) and realised I wasn’t exactly sure how to print to the console....

I don’t think learning something and forgetting it should really be justified, it’s just not an efficient use of time.

If you wanted the benefit of knowing tools that help with linear algebra, memorize that, there’s not point cramming the entire thing just for a class.

I think a good remedy to this issue is spaced repetition software like Anki/SuperMemo. It’s a bit messy to use with math, especially with something like a proof, and they’re meant for cards that shouldn’t take you longer than say 10 seconds to solve. It is doable though if you can break things down into atomic components. And it can be worth more than you realize to have usable access to those memories for say decades rather than till the month after your class

I think it’s difficult though to make classes focus on such long-term memories because tests create such poor short-term incentive structures which aren’t easily replaceable. I think the only way to get around this is to just focus on learning what you want and if you’re missing something that seems useful to acquire it on your own rather than being required to study something and just forgetting it as soon as the test passes.

Lol, I felt amazing the other day for being able to write an ajax request without looking it up after more than half a year of not coding in javascript. I was already looking it up while testing it and was actually surprised when I saw that it was working.

I don't think understanding proofs is essential to understanding AI papers.

A lot of papers are "dressed up" with proofs, many of them bad. But it doesn't matter if the technique can be effective.

You describes how mathematics can be used to create a new programming language/style.

The OP describes how using current programming languages requires very little knowledge of mathematics.

Both of those perspectives can be true and from my own personal experience the OP's perspective rings true.

Interesting, can you give a pointer to the data on software engineering salaries declining?

It seems you agree with me:

>With the exception of machine learning,

I don't know if what you are saying is true. Where is the data?

But I do believe in the long run, you will be right. Software is saturated, and a lot of the infra has been built or commoditized. The value will be there for people who can analyze data.

Too bad I don't find analyzing data as fun or as interesting as banging out a programming problem.

What mathematicians DO is computation.

What a mathematicians WRITE is a formal language used to express computation.

Manipulating mathematical expressions has a name. Symbolic Computation. https://en.wikipedia.org/wiki/Computer_algebra

I'm fairly certain that Hilbert would disagree with you:

https://en.wikipedia.org/wiki/Formalism_(philosophy_of_mathe...

In particular, most modern mathematics can be formalized within first-order logic with the ZFA axioms:

https://en.wikipedia.org/wiki/First-order_logic

https://en.wikipedia.org/wiki/Zermelo%E2%80%93Fraenkel_set_t...

As a concrete example, the metamath project has formalized (and formally verified) huge chunks of mathematics:

http://us.metamath.org/mpeuni/mmset.html

Certainly there are aspects of mathematics which are not formal (beauty, parsimony, elegance, clarity, geometric intuition, etc.) but saying math isn't a formal language is like saying chess doesn't have rules.

Update: So I got drunk instead (which has basically the same effect on me).

Programming is math, except in the real world you have to deal with countless technical and business constraints. So unsurprisingly, theory != practice. The substance might just change in practice because a theoretical answer is completely impractical.

A formal language? Mathematics is a language of hand-waving. And I say that as a person who _loves_ math, even though I didn't take math beyond calc in college. When you translate math into algorithms and real programs, you begin running into problems that shape your solution. Really, you could come up with infinite different solutions to the same problem, all with different characteristics, use cases, strengths and weaknesses. There's no point in making a shared library, because it would be too fucking big and confusing. Better to formulate a solution yourself at this point, if you know what you're looking for, and tune it as you go.

I expect little to no cross-pollination because mathematicians love math and love their own work and love not having to deal with implementation issues, and have no desire to learn anything you mentioned. Unit testing, refactoring, ...none of it. Even many CS profs don't care, it's just the way it is -- a love of powerful ideas, not so much the dirty work of making them a reality. They theorize, and write off everything else as "applications." Nobody wants to write a beautiful algorithm, that also has to handle the sizes of different data types, and consider that not all the data may be in memory, and so on.

So, I remember once as a junior dev, I was asked to write a SQL script to get some data from some tables, etc. I wrote the script and it was taking for ever to run. I scratched my head, had a close look and it was obvious that my script was running in quadratic time (plus, you know- expensive joins and stuff). I rewrote it to run in linear time and, hey, presto- the job was done in a flash.

That is how programmers use maths to do their everyday work.

Note that I don't mean you need to know that what you're doing is asymptotic analysis and so on to optimise your code when it gets bogged down in unnecessarily expensive compuations, but even if you don't call what you do what it is formally known as, you are still doing that thing. And that thing is called "using maths".

It always boils down to use-cases.

Ultimately, what formal verification gives you is a guarantee of structural correctness, but not behavioural correctness. Whether a program behaves as intended or required is still a task for humans. Garbage in - garbage out.

Whether structural correctness is a requirement is a function of the software's criticality and purpose.

You probably don't need it for your blog...

There is one critical FYI. If you require formal verification of your code you have to give up Turing-completeness. https://en.wikipedia.org/wiki/Total_functional_programming

A-priori truths are called axioms.

In the context of the Curry-Howard isomorphism you don't "prove things about programs".

Programs ARE proofs. Not all programs, mind you. You need to be using a dependently-typed language like Agda, Coq or Idris.

The link in my post to the UniMath project is a bunch of codified proofs to various theorems in Category theory, Topology, Combinatorics etc.

Thanks for explaining what I was trying to say much better than myself.

Lots of things, especially with patterns. Let's take scoring for example. Set collection is a common mechanic in games, where you try to collect sets of various things, and generally the more you collect of something, the better you score. But when you're designing the game, how much should that increase?

First there's linear, like 1 is worth 1 point, 2 is worth 2 points, 6 is worth 6 points. For that, there's not a whole lot of incentive to encourage people to make sure they get more cards in that set. But one way in which it could work is if they can only score in certain sets, so they prioritize them because that's the only way they can score it.

But if you want to encourage players to go after a set that they already have the most of, you need to have each one worth progressively more, and a really good pattern for that is the Triangular number pattern. If you recall Pascal's Triangle, the triangular numbers are the third row down, and the pattern is basically 1 (+2) = 3, 3 (+3) = 6, 6 (+4) = 10, etc. to give you a pattern of 1,3,6,10,15,21,28,36. So if you only have 2 of a thing it's only worth 3 points, but if you get 6 of a thing it's worth 21 points, significantly more. You'll see this scoring pattern quite often in set collection games. Offhand, I know Ponzi Scheme and St. Petersburg use it, but I've probably seen it in at least 20 games. If you're not a mathematician or you haven't encountered it in a bunch of other games, you might not recognize the pattern or realize that it's a good way to score set collection.

Another way that is used less often, because it's a much steeper increase, is exponential scoring, i.e. if you have only two items in a set, it's worth 2^2 = 4 points, but if you have 8 of them it's worth 8^2 = 64 points. But if you want the person to win to (almost always) be the person who got the biggest single set, and make people really battle it out just to get one more card in their biggest sets, then this is the way to go. I've seen it work really well in The Rose King, which even includes an exponential chart on the back of its rules going all the way up to like 32 squared, because it's possible to get groups that big (although rare). Apparently an old Alex Randolph game called Good Neighbors also used this.

One I've been playing around with lately is multiplicative, i.e. you multiply the numbers of each of your sets together. So if you have 3 in one set, 4 in another set, and 5 in a third set, your score is 3 * 4 * 5 = 60 points. It opens up an interesting dynamic where sometimes it's better to get cards in a new set than to keep going in one set, but only getting one card doesn't do you any good, and sometimes you'll score more points getting cards in a set you have very little of instead of getting more cards in a set you have a lot of.

Then there's an old one Knizia likes to do where it's basically doing a minimum function on your sets, where you score the set you got the lowest number of points in. He uses it for several of his games, including what many consider his masterpiece "Tigris & Euphrates", as well as "Ingenius". This scoring method forces the user to have to try to get a variety of sets and not to ignore any set, because whichever set they don't get as much of will be the one they score.

Another one I haven't seen too much of, but I've designed a game using it and seen at least one other game that uses it (That's Life! by Wolfgang Kramer, uses it for a single small module in one of its expansions) basically uses a Sine Wave for scoring. If you have an odd amount of a set, you score positive, and an even amount you score negative. Back and forth like a sine wave. It has an interesting property in that the more you get of something the better you score, but at the same time the more you try to get something and fail to make sure it stays an odd amount, the worse you score. So it's like walking a tightrope for that set, and the more you get the better it is and the more dangerous it is at the same time!

Another scoring method Knizia used to good effect in his card game High Society, is kind of the same concept as outliers in statistics (this one is a bit of a stretch, admittedly. There might be a better math concept this applies to). With a set of statistics, you often toss out outliers to get a more even distribution. Well in High Society, it's an auction game where you try to score the most points. However, whoever spends the most money to get those points over the course of the game, loses. Tossed out like an outlier. So you want to do what you can to score the most points, but you have to hold back enough so that essentially you're the second place winner. But of course everyone is trying to do the same thing, so it leads to very tight auctions and gambling when it's safe to bid a little extra to make sure you score something at all.

So yeah, those are several different methods of scoring based on different patterns in mathematics. And that's nowhere near comprehensive, I could probably come up with a half dozen more. As a designer you need to choose which scoring method is best for your game (or you can look into mathematics to find other possibilities).

And that's just scoring. There's all sorts of different aspects of games where knowing mathematics and patterns can help you with your game design.

Sure!

The high level goal is being able to write proof-carrying code in more places.

I think it's important for us to be able to guarantee properties/requirements of our programs and one way to do that is with formal methods. Lean is not only a proof assistant but also a dependently typed pure functional programming language with a decent VM. I would like to be able to ship the program from the proof.

I'm starting from the low level of the Lean VM by adding libffi support so that we can write high-level bindings to C libraries and bootstrap the Lean ecosystem. We need libraries to call databases, parse JSON and other serialization formats, speak HTTP, etc. The goal is to be able to ship an AWS Lambda function written in Lean.

I would agree that the ability to think abstractly is a fundamental skill to designing systems using software. Maths is a good tool for this and it has aided engineers and scientists for centuries.

Find a well-regarded college math curriculum and read the textbooks?

The best collection of resources I've found has been on https://www.reddit.com/r/learnmath/ of all places.

I mean, the college math I had was: calc 1-3 and differential equations (4 classes total), and probability/statistics (1 class). I didn't have to take linear algebra, but I got a good enough understanding from calc and my algorithms class (we studied algos from a theoretical perspective with math, like the CLRS book, so we did some vector and matrix stuff).

Paul's Calc Notes are awesome for calc. But it seems like you have plenty of resources right now, so probably the best thing to do now is actually pick one at a time, and go through it.

This isn't a popular suggestion (and by that I don't mean to say it's rejected or people don't like it, I just haven't heard it suggested before in this context) but at university for electronic engineering we used K.A. Stroud's Engineering Mathematics. This book is surprisingly little focused on actual applications to engineering, it takes you through calculus by introducing the derivative, for example, and then some linear algebra stuff. But what surprises people is that it starts off with the properties of addition and multiplication - it's that simple. It's a book that starts from zero and takes you very, very far. It won't take you to a mathematician's 100 but it'll take you to any serious engineering undergrad's 100.

If I recall correctly it also has problems for you to do - which is key for understanding mathematics and developing a sense of intuition.

I'll stop thinking of money when my survival stops depending on it.

It's a major problem still: teachers neglect giving examples of practical application of a given concept (might be difficult at times, I admit), and miss the opportunity to make knowledge stick and increase the intuitive understanding of the subject.

I still remember my dialogue with my high school maths teacher when first learning calculus, it was more or less along the lines: "But why do we need these differentials?" "Because it will help you to understand integration." "But why do we need integration?" "Because it will help you in your further education." (No, she didn't even mention velocity/acceleration or area below the curve as it's usually done, I had to figure these out myself.)

Consider that the largest employer of mathematicians in the US is the state. Why is that? Why aren't market institutions valuing mathematicians more?

Also, if you look around and individuals who are staffing the top hierarchies of business/market institutions, what kind of credentials are most commonly seen there?

On top of that, in even intellectual subcultures, what stripes of intellect tend to be most respected in US culture?

I think there's a number of ways (some subtle, some less so) in which American society messages people about the status of STEM and in particular about the M, which is almost always about its auxiliary value for something else and rarely respected in its own right.

I think it's plausible there are a number of features of a communist culture that might shift some of those incentives, especially when combined with a generally more intellectual culture.

(Also, this shouldn't need to be said, but this is not an argument about the general superiority of communist society. I suspect that more pragmatic societies do better than more ideologically organized societies.)

Observation: USA curriculum, or, often in recent times, lack thereof, has not seemed to harm the USA’s position in the STEM field

I can't find it at the moment --- it was an essay about a Russian mathematician's experiences coming to the United States and the culture shock with respect to education --- but in it he offered that Soviet academics' relationship to mathematical education was rooted in it being a safe avenue for self-expression and collaboration amongst all the censorship. Students had a drive to solve all the problems they could due to how much of a precious resource these groups were. (I believe the Math Circles program in the United States is inspired by these arrangements.)

Dunno, I spent (wasted) 3 years of my life studying theoretical computer science at PhD level including very advanced parts of (discrete) math and many of those parts are just unnecessarily obfuscated to enable academic careers and an academic version of "demonstrating one's worthiness". There are not many cases of a worse feeling than when you realize after a year and half of difficult studies that the problem was either simple and obfuscated, or that the set of instances satisfying some theory is empty.