Sorry it's a bit of an aside, but I imagine many other otherwise "technical" folks feel the same unfamiliar sense of total loss like when encountering hard mathematics.
Cache, stack, heap, process, thread, socket, file, tcp, http, tls, websocks, socks, soc2???, deadlock, stack, queue, race, atomic, event loop, coroutine, async, database, transaction, index, replication, sharding, consistency, serialization, DNS, load balancer, container, namespace, and so on.
Every sub fields (web/kernel/backend/etc.) has a million/bazillion weird words used in a dozen different contexts and if you read a paragraph of even semi technical software text you will feel like an over stuffed turkey.
Even cache could mean the CPU caches, the page cache, a browser cache, a CDN cache, a Redis cache, or imagine the flurry of words we have that have real world meaning. Session, handle, pool, buffer, stream, channel, event, task, worker, or queue. Generally there is some overlapping meaning but often there isn't.
I mean, we do for some things, especially algorithms (Boyer-Moore). Probably for the same reason the mathematicians do -- there aren't readily available real-world analogies.
And I won't even mention the branded future, with its "Google HyperZipper String Search" and "OpenAI/Red Bull speedmaxx distributed consensus algorithm"...
Well people even name stuff after themselves as well, Fil-C, raylib, etc (I like both Filip and Ray just pointing it out).
Aside: If I butchered some spellings I am sorry. :3
Nah, math is much harder because there is not just the lingo, but also all the math machinery behind it. Each math definition represents some long process behind it, which builds on another process, etc. The knowledge builds on itself , too much more so than computer science.
Learning anything in maths requires weeks of hard effort, learning enough to be broadly comfortable in how an 8086 CPU works can be done in a weekend.
I think what happens is that people often have passing familiarity with a word or topic and presume knowledge, and years (decades) later they realize they knew almost nothing.
I will say that Mathematics is different (for me at least) because unlike the infrastructure computing concepts (IETF type, not IEEE)- which mostly require studying, lab work, and some coding to get your hands dirty - advanced math is just ... really hard. There are IQ issues at play.
Obviously a lot of computing turns out to be mathematics - so there is clearly convergence/overlap as well...
I have had folks tell me cache is just cache in actual interviews. When I have asked them to explain the concept to me, but even beyond that I feel like we tend to think less of our own knowledge of topics once we have acquired it.
Especially ones acquired over years, alongside other work.
The vast majority of what computers do just isn't that complex. I'm not saying it isn't "complex" just that any reasonably smart person can understand how a computer works and still have other hobbies, basically no one can understand phd level mathematics without dedicating their entire lives to it.
But you can have a surface level understanding of mathematical topics as well, ofc some topics might require deeper understanding, but that's true for both.
Any claims of being able to learn 99% of computing in a just 4 weeks even at surface level, is greatly underestimating your own knowledge built over the years perhaps, or perhaps underestimating your own ignorance.
Sure, if you’ve already learned enough groundwork, tcp/ip is accessible in weeks. The same is true of most of the algebraic concepts in play here. And both have rabbit holes you can also spend a much longer time going down (though here I am willing to give the edge to math which offers much greater opportunities for hypergeneralization and new vistas of abstraction along which not only specific rabbit holes but entire new generalizations of both rabbits and holes may be found).
Also, understanding an 8086 CPU is not even remotely comparable to the level of mathematics Terence Tao was discussing above. The 8086 is a relatively basic and concrete topic. You can build a workable mental model of it from a finite instruction set, a handful of registers, and a reasonably straightforward memory model.
From my perspective folks here on HN and in CS often think they should somehow be able to understand advanced mathematics papers at a glance, merely because they are good at basics of programming or computer science (8086). That is not how it works. Most mathematics is not inherently much harder than computer science; both fields require you to accumulate a large amount of foundational knowledge before advanced material becomes comprehensible.
There is an enormous amount of computer science that most programmers are completely unfamiliar with, especially within academic CS: programming-language theory, type theory, formal semantics, compiler theory, algorithmic research, complexity theory, distributed computing theory, verification, cryptography, computational geometry, numerical methods, and so on. Being proficient in one narrow area does not automatically give you the prerequisites for another.
A web developer would not be expected to casually understand a research paper on type theory or approximation algorithms without first learning the relevant notation, terminology, and foundational results. Mathematics is no different. The feeling that mathematical writing is uniquely impenetrable mostly comes from encountering it without the years of accumulated context that mathematicians have silently built-up.
I can show you a paper about an advanced algorithms or chip design, that is large made up of fundamental cs concepts and general physics and even you likely someone with pretty in-depth understanding of CS would find hard. There are orthogonal subjects, for instance my mathematician friends things I am insane reading so much about weird computing topics, and I find his research in some weird number theory thing completely mind-bending.
Try and explain to a lay friend how registers & isa works in-depth with all the details not a hypothetical higher level model so that they can understand the nuance of looking at assembly, limit it to 8086 perhaps, it will take significantly longer than a weekend.
Ofc Terence Tao and his level of intelligence is beyond me, I wouldn't compare but general advanced mathematics is not something folks here couldn't pick up if they actually tried to work on it, just give it a shot (though I would recommend don't start with advanced topics build up slowly I think most people can understand most maths papers even the bleeding edge ones within a few months of serious self-study, and won't even feel that it's after a few years, compare that to the time spent learning software and computing 6-8 hours a days for several years)...
And the difficult part of all those areas of computing is the mathematics part. Which I think is what I am arguing, mathematics is a fundamentally different type of "difficult" to any other subject.
Because otherwise if you think about it all of computing is Maths but with computers...
I don't think people who read the Wireless Fidelity spec can understand any of it in a weekend or anything even to a rough extent.
Similarly with websockets, quic etc. the most you can take away without much prior knowledge is what it does which maps into Maths as well.
CS examples are often easy to picture and understand the motivation for. You can use tools to visualize or play around with them and test them.
Math gets abstract so fast you have to spend a week of research to even understand the problem statement. The the motivations themselves can be completely unclear until you have a lot of context.
I majored in math (B.S.) and upper level math is completely foreign to me.
Every slice has so much depth to it, in Maths it all seems like all of it is required at once but in computing it feels like so little is needed to get started which I honestly feel like is failure of our modern education systems.
But yes Computers being so easily accessible and compilers, documentation and libraries have made computer science so easy to get started with.
Imagine having to implement your own network layer to communicate with someone, you would have had to understand ip, tcp, network layer to an extent like http and etc. and then you finally would have been able to communicate.
In maths that's our reality for a lot of the field, there aren't good libraries, interfaces to help skip the unnecessary details. Hopefully AI might solve it I don't know though. It's fun to hope for it.
That's me when I try reading a trendy computer graphics paper.
compare to
>https://en.wikipedia.org/wiki/Rees_algebra
Most people, especially non-tech technical people, could crash through the TCP article and come out the other side with at least a high level understanding of it.
Most people, even technical ones, could not even get through the first line of the rees article, heck the first statement of the article. And then if they try, they need to know about algebraic rings. And digging into rings becomes totally intractable. None of the words or symbols in any of the articles track to anything even many technical people can grab onto. And this pattern is all over the place in mathematics.
It's not about mastering the difficulty of a topic or it's relative depth, it's about how abstract and removed from anything tangible it is. Anything with math it is always seemingly impossible to get a foothold on the idea anywhere within 10 degrees of explanation. Hell you cannot even clearly understand the problem that is being solved, or anything within 10 degrees of that.
I can understand that this feels like one is so much more complicated part of it is also how the articles were written, wikipedia is not known for quality maths explanations.
But beyond that this comparison to me feels unfair.
Let's take Euclidean algorithm or just modular arthimetic for example what a lot of computing even is based on I feel like that's a fairer comparison. No?
Perhaps that's too easy but I just find this specific comparison very unfair to both Math's intuitive-ness and Computing's complexity. Perhaps I am the one being delusional.
It's a plain observation that math exists on mostly it's own path with little to zero overlap with our lived experiences. If mathematics was a vector, it would have similar magnitude to other vectors, but it's direction would be much more removed from the typical knowledge pack, forcing you to get really close to the origin before you can "hop" over to that math vector. Other "knowledge" vectors, by virtue of being more bunched up, are closer together much further up, if that poor analogy at all makes sense.
Such a small sentence and yet it means very little to me. I understand some constituent pieces, but I don't understand what Z is here other than a 'ring' and I don't really grasp how t^-1 converts this into a generalized family of algebra. It would take me a lot of effort to understand this and use it practically. I find that fascinating because it really is such a small statement that seems perfectly cromulent, but there's a lot packed in there that someone like me is totally missing.
I suppose there may be similar concepts in computer science, but nothing comes to mind that ever stumped me. To be frank, the field has been relatively accessible to me because it hasn't been too challenging. Not sure if that's a personal aptitude thing or it is genuinely simpler.
In lean4, even without mathlib4, TCP/IP is way more code than a Rees algebra.
Math uses dense notation that is gigaoverloaded, and the disambiguating context was historically the leisure and proximity to have someone explain what the lexemes even mean.
lean4 is proving to be very revealing as an uncorruptible referee on a lot of things, including the relative difficulty of computer science and complex analysis.
-- A Rees algebra over ℤ[t⁻¹] is this.
-- That's it. That's the whole thing.
structure ReesAlgebra where
coeffs : Array Int -- integers, indexed by grade
-- grade k means the coefficient sits at t^k
-- negative indices are the t⁻¹ part
-- The "algebra" part: you can add them
def ReesAlgebra.add (a b : ReesAlgebra) : ReesAlgebra :=
⟨a.coeffs.zipWith b.coeffs (· + ·)⟩
-- And multiply them (convolution, same as polynomial multiplication)
def ReesAlgebra.mul (a b : ReesAlgebra) : ReesAlgebra :=
sorry -- it's Array.foldl over index pairs (i,j) summing into slot (i+j)
-- exactly how you'd multiply polynomials in a job interview
-- That's the entire mathematical content of
-- "The Rees algebra is an algebra over Z[t^{-1}]"
--
-- Compare: a minimal TCP SYN handshake in Lean4 would be
-- ~200 lines before you even get to retransmission.
--
-- The notation is the gate, not the math.Z[i], the Gaussian integers, is the subring (of C) generated by Z union {i} where i is the imaginary unit in C, the complex numbers. The Gaussian integers correspond to the integer grid-points of the complex plane, if you want to visualize them.
An algebra over a ring (call it S so we don’t confuse it with R from the previous paragraph) is a like a vector space over S, with the added structure that you can multiply elements of the algebra together (vector spaces only let you add their elements together). So for example the collection of even integers 2Z is an algebra over the ring of all integers Z. The collection of all polynomials with integer coefficients, Z[t], is another algebra over Z.
This is a great example of how dense language gets in math. There are tons of concepts hiding in the unstated background. Many are quite simple to explain individually, but there are so many of them that an outsider won’t know where to start to tease them apart. There’s a good reason to do it this way though; it would take a very long time to say anything in math without ever increasing levels of information density.
His point is the terms are dense too
As for your specific questions, I believe Wikipedia does a great job of answering two of them for a layperson:
https://en.wikipedia.org/wiki/Ring_(mathematics)
https://en.wikipedia.org/wiki/Vector_space
For the others, I’ll say that a formal variable is just a symbol (literally, like the letter t). With such a symbol, we can construct polynomials like 2t^2 - t + 3. Also, there’s no need to only use integers as the allowed coefficients; you can use any ring you like instead.
An “algebra over the ring R” is what I was attempting to define in my comment above. The algebra is “over” R if we can multiply an element of the algebra by an element of R. The useful analogy here is scalar multiplication in a vector space: you can multiply a vector by 2 to double it or -1/2 to reflect and shorten it. More generally, it makes perfect sense to consider some more general version of vectors which can be scalar multiplied by elements of any ring R.
I'm glad you answered them.
It finally makes sense to me, and now I realize I didn't even understand "over" in that context. That Ring wiki page though, um, nope... :D
Fair enough! At a super high level, a ring is just a collection that has a similar structure to what you’re used to “numbers” having. That is, you can add, subtract, and multiply them. Not divide! If we restrict ourselves to just whole numbers then 2/3 is not allowed. We also require that something like 0 and 1 have to be there. “Like zero” means 0 + x = x for every x in your collection, and “like one” means 1x = x for every x. And lastly, we require that the distributive property holds.
Examples include the set of whole numbers (Z), the rationals aka fractions (Q), the reals (R), complex numbers (C). These are all infinite rings, but there are also finite rings such as the set of whole numbers modulo a fixed number n, denoted Z/nZ. For instance, Z/2Z has only two elements, namely 0 and 1, with rules like 1 + 1 = 0. There are also polynomial rings, like Z[t], whose elements are all polynomials with integer coefficients (e.g. 3t^3 - t - 2). You can add, subtract, and multiply such polynomials and the result is more polynomials, so this collection is indeed a ring.
Not like a drink with jam and bread.
All these terms were taught to computer science (and of course math, physics, ...) students as part of getting their degree in computer science, because these concepts are important for many algorithms.
* Determinant calculation:
- The Samuelson–Berkowitz algorithm is best understood in terms of general rings
- The Faddeev–LeVerrier algorithm and determinant calculation using Gaussian elimination work on rings with specific properties (for the Faddeev–LeVerrier algorithm the restriction is on the characteristic of the ring, for Gaussian elimination the ring must be an integral domain (ideally a field)).
* Ring-learning with errors (for post-quantum cryptography and homomorphic cryptography). Here, a specific ring is the central object.
* Number-Theoretic Transform (NTT): Basically a generalization of the Fourier Transform to the ring Z_n. Important for arbitrary-precision integer arithmetic
* Chinese Remainder Theorem. Often only formulated for the ring Z, but it can be generalized to larger classes of rings. Used for example in Shamir’s scheme for secret sharing (cryptography)
* The theory of BCH and Reed-Solomon codes uses a specific ring
* The AKS Primality Test (a really deep result in computational number theory) uses the ring Z_n[X]/(x^r-1).
---
Algebras:
Very often, a ring is constructed from another ring. Examples:
* the polynomial ring R[X_1, ..., X_n]
* The ring of (square) matrices over a ring R
So, using algebras in algorithms often means: "we want to make use use of this additional structure that our (more sophisticated) ring has)". (Associative) R-algebras formalize this concept of "ring with additional structure".
To just give one algorithm for polynomials:
* Buchberger algorithm for computing a Gröbner basis
Other examples:
* Clifford algebras for a lot of geometric problems (special case: quaternions (a 4-dimensional \mathbb{R}-algebra) for rotations in \mathbb{R}^3).
* If you are willing to also consider semi-rings (in this case: tropical semi-rings): the Floyd-Warshall algorithm for finding shortest paths and the Viterbi algorithm for finding the most likely sequence of states in a Hidden-Markov Model (HMM) can very elegantly formulated using the matrix semiring over the tropical semiring.
I'm convinced half the reason people find CS terminology more accessible and Math terminology less so, is that CS terminology tends to be named after stuff, and Math terminology tends to be named after people, and ... sometimes whether the place they lived is a tropical place.
In my opinion: a lot of math terminology is much older than computer science terminology, so the origin of the names of many concepts in math is much more obscure for today's people than CS terminology currently is (and least if you are not into history of science/math).
On the other hand, in my observation a lot more terms in computer science are based on obscure (often pop-cultural) puns. I guess in 50-100 years these CS terminology might seem even more obscure for then-contemporary people than math terminology is today.
For example in search algorithms where you want to search a space without visiting state nodes twice. Each state in the search space is produced by the sequence (a product of) of operators from the start state: elements of a monoid (or group if actions are invertible) which define the primitive steps. Trivial example being generating all permutations of a list. More interesting, enumerate all graphs with some property with pathwidth at most k, by adding one edge or vertex at a time. So now you want to know the structure of this group so you know which sequences of elements simplify and don't need to be tried, and you want to canonicalise each state to throw out duplicates.
And you can think in terms of orbits: if there are some symmetries then you might want to factor by the symmetry group and only visit one node in each orbit, grouping states into orbits with a single representative state. See eg. Pochter, Zohar and Rosenschein, Exploiting Problem Symmetries in State-Based Planners.
> https://en.wikipedia.org/w/index.php?title=Algebra_over_a_fi...
> https://en.wikipedia.org/w/index.php?title=Algebra_over_a_fi...
> https://en.wikipedia.org/w/index.php?title=Associative_algeb...
The latter is what aground asked for in https://news.ycombinator.com/user?id=agrounds
> I’m surprised that rings and algebras would come up in a CS degree. What algorithms topics used those concepts?
I studied computer science (and mathematics) in Germany. I am very certain that this was taught to computer science students, even though (compared to the lectures for math students) the lecturer did not get very deep into these topics.
> most CS students would have been terrified of that.
This is a feature, not a bug. :-)
Seriously: In Germany, the "math for ..." lectures often are intended to be "weed-out lectures" so that students who simply are not qualified for their major get to quit their degree course fast (either by realizing that the degree course is too hard for them, or by (typically) failing math exams so that they get exmatriculated), so that they don't waste many semesters on a degree course which they simply are not suited for.
You clearly write from the perspective of the US-American university system.
In Germany, basically everybody can enroll into a computer science program at a university, assuming the person has a Abitur (Allgemeine Hochschulreife) certificate (these terms are difficult to translate into English) from the grammar school [1]. So, "have it made to college" is like "not having been a complete failure in school". [2]
So, making it to the university is no achievement in Germany, and also no sign of motivation either.
> If these courses are so important, they should be taught in a way that students can understand.
These courses are taught in a way that students can understand, but not in a way where you can afford to slack off.
It is basically a consensus in Germany that a university is clearly a wrong place for you if you are incapable of closing knowledge gaps on your own (for example by reading books from the library), and you don't have the self-motivation to sit over the lecture material for hours to finally understand it.
So yes, I would say that among the possible options, weed-out courses in mathematics are in my opinion likely the least bad one.
---
[1] In years where there was an insane demand for places at the university to study computer science such as during the dot-com bubble, there were some restrictions (numerus clausus), but for computer science, this was always the exception to the rule.
[2] There exist good reasons for puns like "Abitur: nichts gerafft und doch geschafft" (Abitur: Didn't get a thing, yet still passed) or "A-bier-tur" (a portmenteau of "Abitur" and "beer", which suggests that even pupils who are more into drinking than learning typically get their Abitur certificate).
Careful, I think you might be committing an https://xkcd.com/2501/ error.
What even is a protocol? What is a host? What is a ‘stream of octets’? Wiki helpfully tells you octets are also known as ‘bytes’.
Nothing in the ChatGPT conversation is tangible. It's all in the realm of concepts.
Now days of course the chips are small so you have to point to where the multiple gigabyte chips are at.
But they are still quite physically.
Heck a C pointer points to an actual physical location on your machine, if you ignore the MMU.
I’m not sure this gets us any closer to a jargon-free explanation of what TCP does.
Heck there is a standard for tcp/ip over short wave if you want to hear the bytes being transmitted. More widespread, those of us familiar with dial up modems are also aware that network traffic can be carried as actual sound.
Or fiber optics where network traffic is flashes of light.
Or IR transmissions, use your phone camera and you can see data being sent over the air. Not tcp/up but physical blinking lights sending digital data.
All the Wikipedia actually means by ‘stream of octets’ is ‘sequence of numbers between 0 and 255’. TCP is a protocol concerned with sending a message encoded as a sequence of such numbers from one computer to another, over a packet-based network (i.e. one where it can only send limited bursts of information at a time); and it helps make sure that the original number sequence is able to be reassembled, in the right order, and makes sure that all the pieces have arrived.
The fact that people have tried to explain ‘octet’ concretely by pointing to RAM chips or flashes of light in a fiber really points to the fact that a lot of computer people just mentally gloss over a lot of the things that are virtualized at lower levels in the stack.
Yes, those are physical manifestations of ‘bits’. But not necessarily the ones TCP is concerned with.
I can tease apart the Rees Algebra article one bit of half remembered terminology at a time and come out of it feeling like I just barely understand what the topic even is.
I can read the TCP article and feel like I have a thorough overview of the topic and could explain it at a high level to someone else.
To understand the definition of the Rees algebra, you would need to define, mostly in order: sets, groups, abelian groups, rings, ideals of rings, algebras over rings, direct sums of rings, adjoining things to rings, etc.
This is just to understand the definition; to understand its significance in algebraic geometry (which I have no idea of), there are a thousand more definitions.
The issue with trying to understand a concept in math is there is a massive directed acyclic graph of prerequisites leading to these concepts, and one needs to traverse this graph in the right order. Unfortunately, knowing the right order is almost tantamount to understanding the concept itself.
For instance, most people are familiar with polynomials. Take a polynomial in x (with integer coefficients) and substitute x for 5t everywhere. So for instance, 2x^3 - 8x + 3 becomes 250t^3 - 40t + 3.
The Rees algebra Z[5t] (here Z is the integers) is then just the set of all polynomials you can get this way.
If Wikipedia introduced it like this, I don't think most people would have a problem understanding.
The concept is not (at least not always) actually that complicated, like others are implying. It's our communication that is lacking.
The truth is that math is hard: few other subjects have anything close to its crazy conceptual breadth and depth, with hardish concepts being built upon hardish concepts in many layers.
For example, Fourier is more clear to me as: F{t -> sin(t)} = omega -> (...) instead of F(sin(t)) = (...). Or D{x -> x^2}(x) = 2x instead of (x^2)' = 2x
Abuse of notation is very common, like using f(x) both as the function and as the return value at some input x etc. For example, the chain rule is often notated in a way that hides a lot. Math uses so many single letter variables, uses huge formulas instead of factoring out parts and using multiple lines, math people don't seem to appreciate namespaces and dislike nested variable scoping etc.
It's not magic that makes everything super easy, but it helps.
I sometimes think it would be good to rename some of the things that have historical names to mnemonics more descriptive than a proper name. But that would be difficult.
Math just represents this reality on most abstract level, it doesn't care if complexity for some human brains is trivial or almost fractal-like.
Something like TCP is an engineering concept rather than a CS concept. It's not entirely surprising that it's easier to grok. There's also certainly no shortage of hard to understand stuff in eg. Physics
Mathematics would be much more approachable if it just used plain English like `sum(0, Infinity, my_func)` instead of a big Greek sigma with nested function nomenclature. But on the flip side, mathematics being its own language means that a mathematician from any country can read and understand mathematics from a different country without needing to translate words such as "sum" and "infinity"
I suspect if I showed a non-technical person with no background in either math or programming they would think both are nonsense until you explained it to them
`sum function(x) from x=0 to x=infinity`
And if you think about how summation would look in Lisp or APL (which some smart people use to this day), I am not even convinced your argument for the "sum function" notation being superior holds in general.
And it all seems arbitrary anyway. Why are trigonometric functions written in english ("tan" being short for "tangent") but other stuff uses greek letters and other stuff still uses esoteric/abstract symbols? Why is the integral symbol shaped the way it is, and why use super/sub symbols for the bounds versus `integral [0,Inf] ...`?
In my ignorance, I'm assuming math is the way that it is because that's the way it's been for centuries, and messing with it harms its ubiquity. Math notation is not the way that it is because it's particularly well thought out. It's centuries of legacy tech debt that can't be changed. Kind of like how English is a crappy language in a lot of ways, but we can't change it now because too many people use it and you'd never get enough momentum to switch.
And somehow, none of the thousands of very smart mathematicians have done that, or if they had, it has not seen wide adoption. I recommend contemplating on this: if math could be made easier by changing notation, why hasn't this already happened?
Tables, algos, and variables are all things people can generally quickly grasp. The construction is abstract but the function is tangible.
The math is working entirely on abstract objects, using abstract tools, governed by abstract rules. It's just all so desperately far away from anything even technical people have contact with.
They don't seem to have any desire to reconcile their 'craft' with real world applications and this is probably why they're particularly good at it.
I doubt it. Greek letters convey almost no information, whereas (one hopes) the function and variable names are chosen by a programmer to help the reader. The Greek letters used by mathematicians (and physicists) weren't used to convey information, they were used because typesetting, publishing and paper were expensive. They are optimised for brevity over readability.
It was a perfectly reasonable trade-off at the time, but times have changed.
As an aside, some programming languages (such as APL, and to a lesser extent Perl) did emulate the old Greek letter style. "Line noise" is a typical description of the result. No computer language aimed at software engineers and computer scientists does that now.
First of all, no, mathematics would be far less approachable if it did that. Most of the Greek letters used in mathematics don't have a universal meaning, they're context-specific and defined by convention or just prior to use.
Second of all, mathematics is optimized for hand calculation on paper, not long-term programming and code maintenance. Writing out long names over and over on a whiteboard gets tiring extremely quickly, so mathematicians prefer to stick to single-letter symbols.
Mathematicians pretty much universally view typesetting as a distinct step from the thinking part of math, and something you do at the end once you have figured everything out.
If mathematics used plain language, the ability to meaningfully manipulate and understand would go way down. Proofs would become massively tedius.
Of course, notation is hard. Any good mathematician should put a lot of work into it.
I don't know how to say this in a way that won't sound insulting, but I don't mean it to be insulting. Programming, even systems engineering, is a surprisingly shallow field.
I don't mean that it's easy--it's not, it can be incredibly difficult. Difficult and deep are just different concepts. Difficult refers to how challenged you are. Depth, at least as it appears in math, is closer to a structure where concepts build on each other so that if you don't understand one concept, you can't understand further ones.
Programming can be difficult, and it can be intricate, but it is rarely deep in this fashion. Being deep in this way isn't the most important thing.
If I go into an area of programming that I don't have a lot of experience in (graphics, or the linux desktop environment), I will not be particularly useful, and it will not be easy. But I'll not experience the same type of impenetrability I experience when I try to read a paper on topos theory.
One more way of putting it: people are giving the example of TCP. You can spend a decade learning about TCP (or SQL semantics, or web standards). But what is happening is that you're filling in gaps in your knowledge. Meanwhile, in math, you do four years of undergrad, and even if you're a strong student at a typical university, there are topics that are still years away from you being able to touch them.
Computer science is a mix. Parts are deep, parts are shallow. Parts just are math. The odds that I can read a dissertation in computer science are decent. For math, they're much much much worse.
I agree, and I don't think we should be at all ashamed of this.
The beauty of programming is that we can produce incredibly complex and powerful things by manipulating a small set of simple constructs together. There are only a few core tools--iteration, conditionals, etc.--but they can be snapped together into much more capable configurations.
Good programming is the art of deconstructing complex behaviour into these few constructs, and that's really fascinating.
Most of things that are impenetrable in programming aren't about... programming. They are about some actually complex field like math being applied to programming.
For example, a library that does stuff with geometry. You need to know geometry to understand the program, but the program itself will never be complicated. It's the geometry that is complicated.
In cryptography, it's not the program that is complicated, it's the field of cryptography. In AI, it's statistics.
In graphics programming, math is the most impenetrable part, not programming anything. You can be a very good programmer in the sense that you know how to architect information systems and still fail to write a shader because shader programming requires you to know what a "dot" product is and you haven't heard about that since high school.
Your job is to maintain and modernize a system while delivering a constant stream of new features. Your system is several million lines of code, with some multi-thousand line classes, a rulesengine that can trigger nearly unlimited effects at any time, a persistence system that's weirder than anything any of your friends have ever worked with, and hundreds of customers delivering tens of millions in revenue who use the system in incredibly varied ways.
You can't stop to rewrite the thing, you can't just throw features out there and pray, because you'll cause regressions and your existing customers will hate you. You have to fix the thing as you're building on top of it.
But where I agree is that there's no single deep concept that unlocks it all, it's not like you'll fix it by reading a textbook about it. It's complicated, and it's going to stay complicated, no matter how long you work on it.
Like, just the concept of "books" gets you very far. E.g. a file is a like a book, a folder is like a shelf to keep books, a stack is literally a stack of books, a heap is just a place you can pile books in willy-nilly, a database is like a library, a cache is books on your desk versus books in the library, replication is having multiple copies of a book so we can afford to lose some copies, indexing/sharding is like arranging books alphabetically, and so on.
Others are trickier but not much: a process is an app that is running on your device, a socket / tcp / http / websocks is a way to exchange information between devices, a namespace is how the name "Tom" in Tom Sawyer is different from "Tom" in Tom & Jerry, DNS is a way to get an address from a name, etc. etc.
You'll also notice that many of the terms you mentioned are already derived from well-known real-world concepts like pool, stream, channel, stack, queue, worker, transactions. You can mix those with other everyday concepts to make useful analogies.
But I could not even begin making analogies for most topics in Mathematics. I guess this is because advanced topics in Mathematics are just too abstract to map to everyday things.
... communication protocol, method signatures, web components, ssh, CSS media queries, HTTP headers, WebSockets, timeouts, ETag, iterables, async iterables, middleware, CI/CD, build, consistent hashing, signatures, JWT, SSO, OAuth, SAML, XML, YAML, JSON, block cipher, ETL pipeline, SQL, SQL transactions (atomic), relational databases, foreign keys, schema normalization, referential integrity, 1-to-1, 1-to-n, n-to-n, document databases, compound indexes, idempotency, offset-based pagination, cursor-based pagination, P2P, Kademlia, structured vs unstructured network topology, message routing, frontend router, message storm, reconnect storm, locality, encapsulation, cohesion, coupling, design patterns, modularity, Big O notation, raytracing, shaders, VPN, VPC, data schema, schema validation, CORS, preflight-requests, CSRF, ASCII, UFT8, CSP, CPU context-switching, BIOS, bootloader, interrupt controller, ports, BIND protocol, BGP protocol, assembly language, big endian, little endian, register, signals, embarrassingly parallel, serial processing, event loop, binary trees, tree rebalancing, graph traversal algorithms, sorting algorithms, string character escaping and encoding, blob, base64, UUID, timestamp, CLI, Bash, unit tests, integration tests, e2e tests, TDD, stateful, stateless, proxy, nginx, haproxy, config, helm file, k8s, staging, git, push, commit, merge, rebase, cherry-pick, pub/sub, diff, honeypot, buffer overflow, pointer, file descriptor, authentication, certificates, TLS certificates, DNS Zone files, A record, CNAME, TXT record, SMTP, POP3, SOCKS5, Sha256, HMAC, Merkle trees, Merkle Signature Trees, Lamport OTS, Winternitz OTS, SPHINCS, lattice-based cryptography, pg-vector, vector embeddings, API, rate limiting, cookies, sameSite, httpOnly, localStorage, XSS attack, SQL injection, fetch API, module preloading, bundling...
Barely scratching the surface. I think I could probably keep typing all the technical terms I know for at least 24 hours straight. For most of the topics above, I could probably give a 1 or 2 hour lecture on each one from memory. Some I could give a day-long lecture each.
To explain all the terms I know to a basic degree, I would probably need to give a whole year of lectures back-to-back from 9am to 5pm. And I'm just a rank-and-file senior engineer with 15 years of experience.
It's also why the vast majority of software systems are insecure. The average senior software engineer doesn't know everything that they need to know to build secure software. Last time I poked around Coinbase APIs on HackerOne, I found a DoS vulnerability in less than 30 minutes. That's Coinbase, not some startup built by a bunch of recent graduates.
AI cannot avoid vulnerabilities either since it is trained on average engineer code. There's not enough high quality code available on the entire internet to train AI to implement secure code IMO. As impressive as Mythos may be, it's not enough. I don't even think formal verification would provide protection since sometimes issues with the spec itself can provide an opening for a vulnerability.
Cleaning boats, the learning tapered off after a few weeks. With software, I'm 15 years in and it barely tapered at all and it's much more intense. I've been pulling nights and weekends too.
With software knowledge, it would be high information density with little to no repetition. Every piece would provide useful concrete knowledge which would serve to increase technical capabilities and/or security.
You overestimate Coinbase's engineering rigor.
But yes security in modern software systems is a joke. I don't even get paid to fix security bugs everytime I raise them the answer is to slap a sandbox and proxy and call it done.
Now I could hack essentially any system I want. At least DoS or crash them for sure, with minimal computing on my end. They're much more complex than they used to be. Security-through-obscurity used to be a no-no and sometime in the last 10 years it became the main security paradigm.
ETag, SAML, CSP, BGP, haproxy, helm file, k8s, SOCKS5, Lamport OTS, Winternitz OTS, SPHINCS, lattice-based, pg-vector, sameSite, httpOnly. (Or, at least, i have no idea what those are ::)
At least some of these are definitely real things. For instance: "BGP" is the Boundary Gateway Protocol. "Lamport OTS" is a one-time digital signature scheme due to Leslie Lamport. k8s is an abbreviation for a piece of software called Kubernetes.
SAML is Security Assertion Markup Language; an XML based SSO (Single Sign On mechanism).
CSP (Content Security Policy) which allows the application to specify additional security constraints for the browser to enforce.
BGP; border gateway protocol.
Haproxy is a load balancer.
Helm file; another word for helm chart.
SOCKS5 is a tunnelling protocol which allows you to tunnel through a machine over SSH; you can use it to browse the net or access remote services via another machine (hiding your IP)... It's a bit like a basic VPN. Very easy to setup, you can configure your browser (e.g. Firefox) to access the net via a SOCKS5 proxy so if the remote instance is in a different country, websites will treat you as though you are in that country... Just like a VPN except you have to control the remote machine yourself and log into it via SSH with the -D flag.
Lamport OTS is Lamport One Time Signature algorithm.
Winternitz serves a similar purpose but different tradeoffs and smaller signature size.
SPHINCS is a stateless hash-based signature scheme which works by building a tree of OTS keys (Lamport, Winternitz or other) which can be generated deterministically, on-demand.
Lattice-based cryptography is real.
pg-vector is a plugin for Postgres for vector embeddings and it provides some operators for finding records based on the nearest vector.
sameSite and httpOnly are cookie security settings.
Never mind. The answer before me did a much better job.
Just like the famous observation that "anyone driving slower than me is an idiot, and anyone driving faster than me is a maniac" - "jargon" is just any term-of-art that you're not currently familiar with. Attempting to communicate like Up Goer Five is inefficient. The solution is not to ban jargon - it's to:
* Cultivate a glossary for any terms that were introduced _within_ the domain/company, which are not in common usage outside
* Normalize a culture that does not shame asking what something means
"No jargon" is alwys in reference to some assumed knowledge model.
For example, when I claim that my own math texts include "no jargon", this assumes the knowledge of a person who has studied, say, mathematics, physics or computer science.
It's why less experienced devs are sometimes mystified seeing a seasoned dev, given a vague description of a bug, guess the cause in code they didn't even write.
Similarly, at some point somebody pointed out to me "the reason you're confused is that the bold on that variable means it's a matrix"
e.g. to use a very simple example on a white board "3" is "overloaded" as:
- the integer 3
- the rational number 3
- the whole number 3
- etc
When you write a proof in Lean, you have to specify the the type of "3" you mean.
Having using Python/Perl and Java over the years, I get that some math folks found handling this daunting or at a minimum friction to getting into using Lean.
LLMs seem to have been a big help here just for the "translate my math notation into a proof" feature.
A decade or so ago I wondered if the reason maths was hard was the names being optimised for writing by hand. Everything's single letters if they can get away with it, so when mathematicians run out of Latin alphabet, they use Greek, bold, etc.
Even integration's ∫ is a fancy elongated s.
CS version would be e.g. integral(function=some_named_function, from=a, to=b, with_respect_to=argument_of_function), which may be longer, but is less opaque, especially when you get in so deep there's 3 other people in the world who've looked into this specific problem and you had to invent your own operations.
But that's all an outsider's perspective. I stopped with two A-levels in maths and further maths.
Same reason why we write 5-3, not subtract(minuend=five, subtrahend=three).
Interestingly, discrete math feels the most "verbal" of all the subfields of math I've encountered (I haven't gone very deep). I think this is because notation in discrete math is is somehow closer to compressed prose or logic, whereas other forms of math use notation to fill in for long sequences of symbolic manipulation.
Not sure if that makes sense... I'm curious whether anyone else experiences it that way.
People genuinely struggle to think verbally or visually once we extend beyond 3 dimensions and start talking about infinite-dimensional constructs, uncountable sets, and so on...
And math is, as you know, a deep but traversable graph. The traversal inherently requires a familiarity with the nodes you pass through when reaching a foreign or more difficult concept.
However, I'll give you an example. If I read through more complex math that I’m not comfortable with in Sage, I can build an intuition for the structure of the problem more easily than if I view the “raw” notation. In that sense, it is easier to for me to “approach” — but approaching something is very different from fluently using it — and I’m under no illusion that approaching a topic is the same as beginning to understand it.
Again, this is definition-dependent. To me, “approaching” something means beginning to glean how I might one day understand it. E.g. watching a 3B1B video feels like “approaching” a topic. Here we reach the limits of language already :)
whether he succeeded, is debatable. But APL is definitely powerful, succinct and "regular".
In APL you don't infer the operation from the types at all. × is elementwise, +.× is inner product /always/, on scalars, vectors, matrices, whatever. The glyph tells you what happens. Nothing is bold, nothing is inferred, nothing depends on what your professor assumed you'd absorbed.
I've been trying to get into Iversonian languages myself with the book: Calculous on J
https://www.jsoftware.com/help/learning/23.htm is the closest i've found, but wondering if i'm missing something perhaps, Julia?
tyvm
Imagine that instead of being able to use high-level programming languages, you had to write in assembly everywhere, all the time.
That's what software engineers and computer scientists' suggestions of redoing mathematical notation fee like to mathematicians.
These efforts also don't go anywhere because research mathematics moves beyond elementary arithmetic very quickly, and once you're there, "descriptive" notation becomes as incomprehensible as whatever mathematicians use.
This is one of the great things about Lean becoming used for more and more mathematics: understanding exactly how an operator/function is defined is just an IDE click or few away. It completely removes the ambiguity present in hand-written proofs, although it still can require a lot of reading to actually meaningfully understand the definitions.
but then I take a look at literally anything the Haskell people do and realize that it probably wouldn't have helped.
"""During his own Google interview, Jeff Dean was asked the implications if P=NP were true. He said "P = 0 or N = 1." Then, before the interviewer had even finished laughing, Jeff examined Google's public certificate and wrote the private key on the whiteboard."""
That, as well as how long we've been doing it (thousands of years!) and so how much of the more accessible parts we've explored very thoroughly.
Pronouns like you/me/he/she/they/them are context dependent in everyday English writing but they're only ambiguous when the context is unclear, otherwise most people have no trouble dealing with them at all!
Isn’t this the field with a “closed” “set”, an “open” “set”, oh and also a “clopen” “set” for some reason?
I like to emphasize that the ideas are usually very simple at their core. Sometimes they map to kinds of objects or reasoning that non-mathematicians use implicitly all the time in their daily lives, mathematicians just have words for them and so are able to use them explicitly.
And I suspect the density of the language/terminology may give the wrong impression about how mathematicians think about the math they are working on. I mean, different people think / experience / practice math differently of course but IME the underlying thought about a particular problem tends to be much looser and concrete than formal math writing would imply.
That more formal language is needed of course because at the end of the day, it is how we communicate our thoughts in the way that other mathematicians can understand them, not to mention how we can check our own thinking
"The special fiber is the associated graded ring.....and that the filtration admits sufficiently simple homogeneous lifts of the three generators, then one might prove"
In any other context I would at least have some degree of intuition about what is being discussed, but in in math? Absolutely no idea. And usually if I start digging and turning over stones to uncover meaning, I'm just met with even more totally dense code-word language. Unlike other fields were digging is usually quick to relieve ignorance, somehow in math it tends to get worse.
I'm sure I am capable of grasping this if I took the time, and perhaps even what is being discussed it rather intuitive, but the incredibly density of the nomenclatic swamp you have to trudge through for math is totally unrivaled.
One unfortunate feature of published pure math research is that often the ideas are quite accessible and straightforward and don't really require special abstractions or terminology, but those get used anyway because for someone who already has a math PhD it saves a bit of effort.
It doesn't matter if natural numbers include 0 or not, what matters is how you define them, not how you call them.
This makes them also bad at naming things because...there's a definition anyway.
Most other fields do not have or can't have the same luxury, so naming might be more thoughtful.
For poor old me, too many wikipedia articles on algorithms useful mostly or only for programming are described in formulas rather than simply code with detailed comments. Scrap the whole page and just gimme the code :( Not even to copy and paste, because that's a language I can understand, and enjoy learning.
Computer science/engineering strays from this, binary systems don't really track nature much, and hence a lot of their own unrelateable nomenclature arises, and then there is math, which is just way far out there on it's own plane of existance.
People in their second year of graduate school only get to about the early 20th century in terms of understanding. Third year is getting to about the mid-century. Fourth and fifth years get kind of to modern times but with increasingly smaller breadth.
Big wrapping operations like sums, integrals, and matrices, then what's nearby them, give you a very good idea of where things are going context wise.
I'm sure having a compact notation is absolutely invaluable for people who dedicate their lives to maths, but for someone with just a passing interest, I find it more obscuring than helpful. I feel the same way about music notation.
Many mathematicians do what you do as well!
Some areas are hard in different ways. I could never quite wrap my head around the way logicians have to think. A clever combinatorial bijection is a work of art you probably can explain to a undergrad class easily but good luck coming up with it. And number theorists will throw the kitchen sink at their problems: no area of math is safe from getting used by them.
People who do this have spent years of their life thinking in this language and studying it, so it is going to be hard. We're also not good at communicating the intuition which for algebraic geometry often comes from other fields.
Math isn’t necessarily hard, but it’s incredibly dense
A simple statement like let f(x) be a continuous function can carry a lot of definitions
In that statement, if you missed the day in class where they covered continuous functions it might not even register that it’s a well defined term
And that’s the most over simplistic example I could think of
As a math major, I remember that being one of the first lessons I learned, that every single word could be carrying a lot of weight so to look things up in detail if I was ever struggling on a problem. One of the oldest entries in my memory.md file