Stephan Rehfeld retweeted
The Internet, as it was designed and implemented by universities and research agencies, is dead. It died a long, slow death, starting in the 2000s. Out of the Internet's dead body, a Frankenstein's Monster was created that we use today - a commercial network that degrades users to mere service consumers and is indistinguishable from AOL, CompuServe, or the German BTX system.
The Internet was originally designed as a decentralized network where every node has a public address and can be both a consumer and a provider of any service, creating a network of equal nodes.
The first nail in the coffin was IPv4 itself. More precisely, the decision to use only 32 bits for addresses. Besides, many addresses are not usable (network broadcast addresses, private addresses, reserved address spaces, etc.). The 32-bit design flaw allows only 4.2 billion addresses. In the 1980s, we already had more humans on earth than that.
The second nail in the coffin was slow Internet access. When the Internet was opened to the general public, people used dial-up connections via modems. The peak bandwidth here was 56 kbit/s. This already separated the providers of a service, who usually have high bandwidth connections, from users of services.
The third nail in the coffin was asymmetric Internet connections, common with DSL and FTTH. People have more bandwidth for downloading than for uploading, preventing them from also being providers of services. Want a symmetric connection? Be prepared to pay an insane amount of money to your carrier.
The fourth nail in the coffin is carrier-grade NAT. With carrier-grade NAT, you share your IPv4 address with several other customers. While slow or asymmetric Internet access just makes it harder to be a provider of a service, carrier-grade NAT makes it impossible. It degrades the person to be a consumer only, without a real connection to the Internet.
The fifth and final nail in the coffin is the so-called "cloud" technology (which is, in reality, just someone else's computer). The once decentralized Internet, where many people provided mail servers, web servers, IRC servers, news servers, and where people ran decentralized P2P file-sharing software, has transformed into an extremely centralized structure. The number of ISPs has drastically reduced. Services are now hosted by a few "cloud" providers, which accumulate more and more IPv4 addresses. Content is provided by a few content delivery networks, and services are behind the reverse proxies of only a handful of companies. The Internet was once a common network of many smaller networks; nowadays, it mainly consists of the networks of a few big players.
Realize it: The Internet of the 90s does not exist anymore. And I don't mean that the old web doesn't exist anymore (it also died). I mean that the Internet itself died. It is not the network of liberty and anarchy anymore. It is a network to play out content to you, to make you consume, to make you click, to make you waste time.
Stephan Rehfeld retweeted
As the UEFI BIOS is the bootloader for GRUB2, which in turn boots the Linux kernel, which then boots systemd, which initializes several processes and Wayland, which starts the window manager, which finally launches the browser, the only application you might be using on your computer in modern times: Would it not be easier to just replace the UEFI BIOS directly with the browser?
Stephan Rehfeld retweeted
Object-oriented programming and its consequences have been a disaster for the world of computer science. They have greatly increased the work for those of us who work on "enterprisey" projects, but they have lowered the knowledge about computers, made developers' lives unfulfilling, disconnected computer science students from the computer, led to widespread state across software, and inflicted severe damage on the CPU cache. The continued use of object-oriented programming languages will worsen the situation.
1. Mixing together data and code is a bad idea. That is the reason why civilized programming languages like Rust and Haskell do not do it. Mixing together data and code pretends that there is only one valid interpretation of the data. Besides very simplistic textbook examples, this is always not true. Good programming languages such as Rust reflect this insight by cleanly separating data (structs) from code (traits and implementations of traits).
2. Inheritance is a bad idea. Even textbook examples like "You have a Person base class and Students and Lecturers inherit from Person" break down in real life (at least as soon as your computer science professor starts to study Philosophy). Multiple inheritance makes the situation even worse as you are then in the diamond problem. All reasonable generalizations are already described in functional programming with concepts such as functors, applicatives, and monads. (Okay, to be fair: Many users of OOP languages have realized this and now try to use composition instead of inheritance).
3. Encapsulation, which in almost all cases comes with OOP, is a stupid concept, where developers are burdened with the repetitive task of writing getters and setters for their encapsulated variables. Oh, they can be generated? That they can be generated is not worth it even in a project.
4. State is spread all along the software. Every object encapsulates data, and this data is usually mutable. Mainstream OOP languages do not have semantics to create immutable objects. They usually have semantics to ensure that a function does not alter an object (Java does not even have that), but no possibility to declare "Hey, this object is immutable and you can rely on that." That breaks your neck in almost all situations where you write concurrent software.
5. Polymorphism and late binding are a bad idea. In most cases, you want early binding instead of late binding. Late binding means that your program has to look up which function to call. That means all the components on your CPU that try to prefetch stuff from RAM into cache are clueless, which means that the probability of cache misses is high. This wastes a huge pile of your potential CPU power, as the CPU waits for data from the very, very slow RAM. Ever wondered why your CPU becomes more powerful while your software runs slower and slower? Well, that's the fault of by-default late binding in OOP languages.
6. Computer science students who learn OOP languages usually know little about computers:
- Pointers? Oh, that's this complicated C stuff, isn't it?
- Difference between Heap and Stack? Aren't both collections?
- CPU Cache? Never heard of it.
Object-oriented programming was a great mistake of mainstream sofware development in the '90s. But you don't want to program like it's 1999. Hence, learn well-designed languages like Rust and Haskell.
Stephan Rehfeld retweeted
Computer Science is dead, with no paradigm-shifting innovations for decades.
Look at your computer. The von Neumann architecture, which forms the foundation of how your computer is built, was developed in the 1940s.
The Instruction Set Architecture (ISA) of your CPU was either developed in the 1970s (x86) or in the 1980s (ARM).
If you're using Linux or BSD (which also includes macOS), the concepts of your operating system were developed in the 1960s and 1970s. If you're using Windows, the concepts were developed during the creation of OS/2, which began in the 1990s.
Modern programming languages mostly still use syntax similar to what C introduced in the 1970s. Most programmers still code in an imperative way. Functional programming concepts, which have become more popular in multi-paradigm languages, are also decades old.
The idea for a worldwide computer network was conceived by Licklider in the 1960s. TCP/IP, which we still use today, was finalized in 1983. HTTP was the last major innovation in 1991.
Computers with graphical user interfaces? Developed by Xerox in the 1970s.
Neural networks performed simple pattern recognition decades ago. They have only become larger and more computationally intensive. The result? They demonstrate that much of the work we do isn't creative or innovative, but rather stupid repetition. They prove that most "creative work" is merely a probabilistic text-in, text-out job.
The golden era of computer sciences is over since ages.
