Comments by "Lawrence D’Oliveiro" (@lawrencedoliveiro9104) on "Computerphile" channel.

  1. 1:52 “Make sure everyone’s on the same page.” Flips to a different page
    1000
  2. The separation between the S and T servers is the separation between authentication (proving you are who you say you are, done by S) and authorization (what services you are allowed to access, controlled by T). Each one can be updated independently.
    253
  3. 3:37 Note that each λ represents a function definition: so “λx.λy.x + y” is not (directly) a function of two arguments: it is a function of one argument (x) returning a function of another single argument (y) which returns the sum!
    139
  4. Here’s a key acronym to remember about GPUs: “SIMD”. That‘s “Single-Instruction, Multiple-Data”. It has to do with the fact that a GPU can operate on a hundred or a thousand vertices or pixels at once in parallel, but it has to perform exactly the same calculation on all of them. Whereas a single CPU core can be described as “SISD” -- “Single-Instruction, Single-Data”. With multiple CPU cores, you get “MIMD” -- “Multiple-Instruction, Multiple-Data”, where each instruction sequence can be doing entirely different things to different data. Or in other words, multithreading. So even with all their massive parallelism, GPUs are still effectively single-threaded.
    130
  5. 2:56 The key lies in observing that each half of the original data block does not go through the F-block to get to the next stage. The only use of the output of the F-blocks is to xor with data blocks. And xor is reversible: xoring with the same bitstream twice gives you back the original bitstream. That’s why the same sequence of bit-mashing works for both encryption and decryption. It really is that simple.
    119
  6. The irony being that he was a linguist, but linguists found little or no use for his mathematical innovation. The computer scientists, on the other hand, lapped it up.
    101
  7. Unless the question was “why is half your brain missing?”
    68
  8. 7:50 Some people might be accustomed to other VCSes which automatically assume that every change you have made to your working copy is to be included in the next commit (e.g. Subversion works this way). Git doesn’t do this -- it requires you to explicitly add changes to the “index” to be included in the commit. This is because Git recognizes that you often make multiple sets of changes -- for example, while fixing one thing, you notice something else that needs fixing, that is quite unrelated. So when you actually get round to committing your changes, you can pick and choose which ones go into the same commit, and which ones to leave for another separate commit. And some things, like debug message lines, can be left out altogether.
    62
  9. Some people, faced with the problem of comprehending a presentation on regular expressions, like to distract themselves with a well-known and overused Jamie Zawinski quote. Now they have two problems ...
    56
  10. I remember in the mid-1990s, working on the first automation system for the NZ DNS registry, and learning Perl at the same time. The script we started with (from the Australian registry) was storing 2-digit year numbers. A (presumably more experienced) colleague immediately said not to worry about it, that there was no way our particular software would still be in use by the end of the century. I disagreed and insisted that years be stored as 4 digits. That was purely out of instinct, which turned out to be correct.
    56
  11. 1:33 Two keys, not three for triple DES. That’s what it says in Tanenbaum’s Computer Networks text, 4th ed, page 740. You encrypt with key K₁, decrypt(!) with K₂, then encrypt again with K₁.
    55
  12. 1:16 Space before colon, but not after comma. ‌twitch‌
    49
  13. My attitude to comments is that they shouldn’t say just what the code does (the code itself does that), but why the code is doing what it’s doing. Perhaps a comment on the regular expression could be expressed on the same basis.
    46
  14. That, and the fact that their “end-to-end” encryption wasn’t end-to-end at all, it was end-to-middle, middle-to-end. They were also criticized for using AES-128 instead of AES-256, but really AES-128 is fine.
    42
  15. 10:02 And one nice thing about scan codes is they don’t distinguish between modifier and non-modifier keys; it’s just “key «n» has been pressed” and “key «n» has been released”, it’s up to the software to decide if key «n» is a modifier key or not. And you can distinguish between e.g. left-shift and right-shift (they have different scan codes), and implement other fun custom behaviours.
    40
  16. 9:54 Back when Ethernet was expensive, Apple developed its own, cheaper† “LocalTalk” layer-2 connection system for its AppleTalk protocol stack. Besides the much lower bandwidth and lower-spec wiring, another way they kept the cost down was to omit the collision-detection hardware. An Ethernet node could notice if someone else started transmitting while it was doing so, but LocalTalk could not. Instead of being “CSMA/CD” (the “CD” standing for “Collection Detection”), LocalTalk was “CSMA/CA” (the “CA” standing for “Collision Avoidance”). †Yes, “Apple” and “cheaper” in the same sentence. Not something that happened very often, even back then.
    38
  17. 3:56 ALGOL 68 had its own terminology for so many things: types were called “modes”, addresses/pointers/references were called “names”, and instead of saying “input/output” or “I/O”, they coined the term “transput”.
    35
  18. 6:10 A common use for mouse-moved events is changing the mouse pointer, e.g. making it an I-beam pointer when the user moves into a text field, to indicate that they can type there.
    29
  19. CP/M was strongly influenced by DEC minicomputer timesharing operating systems of the 1970s. The name “PIP” (“Peripheral Interchange Program”) for the file management utility is exactly that of a corresponding DEC utility found across several of its OSes. Only of course the DEC versions had a lot more functionality. One thing, though: DEC OSes had multi-character device names; pity CP/M had to “simplify” them down to a single letter.
    29
  20. 5:47 If you think about it, the OSI seven-layer model included a “presentation” layer, between “transport” and “application”, that nobody could fit into the reality of TCP/IP very well. But SSL/TLS fills that layer very nicely.
    28
  21. At least XML allows comments.
    27
  22. 9:41 Remember, none of these public keys is confidential. The problem is, you have to trust they are authentic, that they really came from the people they say they’re from.
    27
  23. A couple of significant notational differences between C and Pascal are, when declaring variables, C inherits the Algol syntax of type-spec before variable name: “«type-spec» «var-name»” whereas Pascal invented its own syntax: “«var-name» : «type-spec»”. And also pointer dereferencing: C uses a prefix operator “*«pointer-val»” whereas Pascal has a postfix one: “«pointer-val»^”. This may seem very tomayto-tomahto, but consider how C++, which inherits C syntax lock stock and barrel, is now trying to deal with newer features involving dependencies between types, for example between the arguments to a function and its result type. It now finds that, in addition to the C syntax of putting the return type before the function name, it also has to add an alternative syntax where the return type comes after the argument list, à la Pascal. As for the pointer issue, this may not occur very often, but back in my Mac programming days, more than once I had to write an expression like “thePort^^.theGDevice^^.gdPMap^^.pmTable”, which in C would have had to become “(**(**(**thePort).theGDevice).gdPMap).pmTable”. (These were structures defined for interfacing to the Mac system, not created by me.) Which would you prefer?
    27
  24. 20:23 This is where “quality of service” (“QoS”) comes into play. TCP/IP allows for marking packets with indications as to whether timeliness of delivery is more important than reliability of delivery: that is, if a packet is taking too long to be delivered, it might as well be dropped rather than delivered too late to be of use.
    27
  25. You didn’t mention Ada, which was an offshoot of Pascal created as the result of a competition held by the US Department of Defense, to create a language suitable for doing systems programming for safety-critical and mission-critical systems. There is still Ada code in use today, for example controlling the life-support systems on the International Space Station (running on Intel 386 processors, with no Microsoft code anywhere in sight).
    25
  26. In his honour, instead of #hashtags in future, let us have £poundtags.
    24
  27.  @IceMetalPunk  Code can only do what it does. Comments that describe what the code does are obviously superfluous, but ones that explain why it is doing what it is doing should be essential. How could code ever be “self-explanatory” in that way? It cannot.
    23
  28. The three basic objects in Git are blobs, trees and commits. A blob represents the contents of a file, and is identified by the SHA-256 hash of its contents. A tree associates names with blobs, and represents a snapshot of source tree contents at a point in time. A commit holds a pointer to a tree, and to zero or more parent commits, as well as information about who did the commit and when, an explanatory comment etc. Trees and commits are also represented by SHA-256 hashes of their contents. This is why a commit holds pointers to its parents, not to its children; because once the commit has been created, it cannot be changed (e.g. to add child pointers) without losing its original SHA-256 ID. Branches and tags are just pointers to particular commits. They have no associated SHA-256 hashes, so they can be added, removed and changed at any time.
    23
  29. 7:04 Notice the only kind of recursion allowed is tail recursion—there is nothing after the B that occurs in the substitution for B itself. This can be implemented with simple iteration, without a stack. Otherwise, it would no longer be a Type 3 grammar.
    22
  30. 3:41 Tip: You can do “git show --raw «commit»” to get a list of the files affected by that commit. You can similarly list the files affected by each entry in the log with “git log --raw”.
    21
  31. 6:57 There is another technique, called “pipelining”. Or, in industrial terms, you set up an “assembly line”, where one person just butters the bread, and passes the slices onto the next person to put in the cheese and slap them together. Modern CPUs use this technique as well as multiple processors. And then there’s also caching.
    20
  32. If there was any “spite”, it was not on his part, but on that of Larry McVoy in cancelling their BitKeeper licence.
    19
  33. 27:05 That is the inevitable fate of every GUI architecture, to get more and more complicated over time. There are no “simple, efficient” GUIs.
    18
  34. 5:19 Isn’t this also where the “CIRC” (“Cross-Interleave Redundancy Checking”) comes in? The bits are arranged in a pseudorandom scrambled pattern (which is unscrambled as part of the decoding process), so that any contiguous run of errors on the disc is spread across a larger area after unscrambling and affects a smaller proportion of bits within that area.
    17
  35. Better for number-crunching. Wipes crumbs from mouth
    17
  36. The term for those artifacts is “mosquitoing”. They are the image equivalent of “ringing” in digital audio.
    15
  37. 2:10 The later term for this separate processor on the ARPAnet was “Interface Message Processor” or “IMP”. It was probably necessary because IBM mainframes did not like to be interrupted for every little bit or byte of data -- their I/O was done through elaborate “channel” processors which could be given sequences of operations to perform without bothering the CPU until the sequence was complete -- or some unusual situation arose (e.g. an I/O error). This probably also eased the problem of implementing the network, because the IBM OS wouldn’t have been interactive. IBM preferred terminals that operated in “block mode”, where you had fields defined on-screen by previous computer output, that you filled in locally, and nothing got sent back to the mainframe until you hit the “Send” key.
    15
  38.  @gordonrichardson2972  The 486SX was a completely cynical marketing ploy. It lacked the (functioning) floating-point hardware, but you could buy a 487SX chip to add this. However, the 487SX was more than just a floating-point coprocessor: it was actually a complete functioning CPU. Plugging it in caused the 486SX to turn itself off and hand over all functions to the 487SX!
    14
  39. 6:14 Unfortunately, the Java specification is barely smaller than the C++ one. So much for trying to “simplify” -- it just introduced its own complications ...
    14
  40. Newton’s Third Law, action = reaction; contemplate the Zen of physics: when you a press a key, the key presses back.
    14
  41. Thumbs down if your calendar still goes by “AD”.
    13
  42. 4:05 Not just a security issue: think about languages that require a front-end processor (e.g. Chinese/Japanese/Korean) to translate keystrokes into a large character set: putting this in userland makes it more flexible, replaceable, configurable etc.
    13
  43. 8:34 So lex was written by a guy named Lesk. So near, and yet so far ...
    12
  44. I’ve wondered why telephone numbers don’t have check digits. It would reduce the incidence of wrong numbers by 90%. Yes, it would make them longer. That mattered more back when they might only have been 5-6 digits. Now that they are commonly 7-8 digits or longer (particularly for mobile phone users), it seems less of an issue. Come to think of it, why are we still using telephone numbers? They’re an idea that dates from the 19th century. Why don’t we use 20th century Internet-based technologies, such as the Domain Name System? Use names, instead of numbers, to connect to people.
    12
  45. 6:19 I remember a description from the time that “pointers are the gotos of data structures”. And guess what: Pascal had gotos as well. Not even restricted gotos: they were a full implementation, including being able to jump out of an inner procedure/function call into an outer one. This was, of course, a way of doing exceptions before languages had the concept of “exceptions”.
    12
  46. 5:22 You can set your working directory to any subdirectory of a project directory. Git will automatically go up into parent directories until it finds one containing a .git subdirectory, or until it hits a filesystem boundary, at which point it gives up.
    12
  47. The Apollo Guidance Computer used “rope” memory for its ROM -- the bits were encoded in the weave.
    12
  48.  @MatthewStinar  COBOL didn’t really have the concept of arithmetic in bits. It preferred to do it in decimal, with a precision of 18 decimal digits.
    12
  49. The paradox of modern cache-intensive CPU architectures: RAM is cheap, but accessing RAM is expensive.
    12
  50. 7:17 If you operate in high-dynamic range formats like EXR, which has floating-point pixel components, you have room to both overshoot and undershoot. Then you can renormalize the image using a filmic response curve or something without clipping.
    12