Agreed. Those topics are very specific instances of general principles that are usually taught in a security course.
What did OP mean by "secure client/server architecture" though? What are the basic/fundamental principles behind it, that are NOT covered in cybersec education?
By this logic, all stock traders should be considered employees of the stock exchange they use. Uber is just like a stock exchange - a match making service.
* Traders/riders on a transaction/ride pay the exchange/Uber for this service.
* Traders/riders are free to trade/ride as much they want to, at any hour of the day, provided there's enough liquidity in the market (surge pricing etc.)
* If a trader doesn't cut a profit on a trade, it's the trader's problem not the exchange's
* If an Uber driver doesn't drive enough to earn a living wage, it's the driver's problem not Uber's.
BGP is a policy-based routing protocol, whereas OSPF/RIP are performance based. BGP is not "the" routing protocol, just that it's widely used because of its simplicity.
This article is missing quite a few things that's of interest to programmers:
1. IPv4 fragmentation & reassembly
2. Centralized (Dijkstra/OSPF) vs. Distributed routing (distance vector/RIP) - stuff you see in Algorithms class
3. TCP mechanisms: congestion control mechanisms that the user can configure (Cubic/westwood/new reno), flow control, retransmission timer calculation (exponential weighted moving average)
4. explicit congestion notification and other add-ons, which can be enabled in the OS by the user
5. Active Queue Management and enabling QoS on your system: stochastic fair queueing for example
6. the recently introduced TCP Fast Open mechanism
I did not mention compilers in my comment. Do you mean that if I use LLVM compile a C program then I get the same assurances as when I compile a Rust program?
Let's say you are using LLVM to compile a Rust program, and an "equivalent" C program. You can compile both of them down to IR, and then enforce type safety at the IR level. Doesn't that ensure that you can prove properties about the program at compile time?
You could use LLVM to compile any language to LLVM IR, and then to machine code using a backend. Does that mean every language has the same properties as Rust?
If Node/Java/Go use GC (or VMs), then aren't they more safe than Rust?
So why does C, for example, lack Rust's memory safety semantics? Is it something to do with the design of the language itself? Can Rust predict user input, whereas C cannot?