1,027 karma · joined April 23, 2020
I am not Dr Hipp, and therefore I like run-time checks.
Regardless of its many warts, Cobol cannot be accused of being unreadable. Verbose, yes.
I used to bind the Compose key to Caps Lock, but I've recently decided that Right Alt is a better choice.
Another commenter mentioned WinCompose, which I have used very successfully with Windows 11. On a Mac, you might try https://github.com/Granitosaurus/macos-compose, which is quite usable, provided you install Karabiner Elements for the remapping.
Again on System/360, I benchmarked BCPL procedure call costs against subroutine call costs in Fortran G (the non-optimizing compiler). BCPL was about 3 times faster.
That said, as soon as you added multi-tasking (what we'd now call threads), it all went to hell. It's not an accident that one IBM PL/I manual of the 1960s said “Do not use procedures, they are expensive.”
As mentioned by others, it was the tiny stack in the 6502 that killed this approach. I appreciate all those who pine for the 6502, but it made implementing modern (even for the 1970s) languages almost impossible.
One additional example of the technology of that time. In 1968, I was a computer science student, and found myself called upon to arrange a demonstration of remote computing. The university at that time had no timeshared computing facility, so we used IBM's Call/360 service. The terminal was an IBM 1052 (big clunky printing terminal) with an acoustic coupler. To move this across campus, we arranged for a truck with 2 or 3 people to put the thing on a dolly, put it into the truck, and move it into the student union building. Later that day, the truck, and the helpers, came back and we reversed the process.
I really like my ThinkPad!
Do these proofs involve boojums?
My first machines were the IBM 7044 (36-bit word) and the PDP-8 (12-bit word), and I must admit to a certain nostalgia for that style of machine (as well as the fact that a 36-bit word gives you some extra floating-point precision), but as others have pointed out, there are good reasons for power-of-2 byte and word sizes.
The cueing theory seems misguided, in teaching kids to regard pictures as the source of information. I'd say that teaching kids to read requires a mix of activities, with a heavy dose of phonics, but also activities that create a joy of reading, by showing interesting people and stories. I can't see how cueing helps.
Cueing reminds me of some of the stranger ideas in math pedagogy in elementary schools, notably that rather than learning algorithms for arithmetic operations, kids should invent their own, and maybe have several, which they choose from in a specific problem. Of course, some students have much more difficulty than others, but there really are some basic ideas they must master in order to be competent at arithmetic. Allowing a kid to amass a forest of partially working techniques and then have to hack through it to solve any problem seems ridiculous to me, much like putting a student driver in a car, with no training, and telling them to try various things to see how to drive to a given point without getting killed.
I would argue that the right way to think about dependencies, as some have alluded to, is to do a risk/benefit analysis. On the benefit side, how much work would it take me to duplicate this component, how well will it suit my needs, and so on. On the risk side, everything from continued maintenance to security and licence issues (for both free/libre/open-source and proprietary components). Then risk/benefit asks for ways of ameliorating risk, such as by forking code, or paying for support.
The right way to think of adding a dependency is to ask and answer questions like this prior to adding it. This is not the way that JavaScript developers used left_pad, they just said “it's in npm, so it's good.”
Wirth's Pascal-P compiler of 1974(?) used the same idea, also in aid of a highly portable compiler. I have never been able to find out whether this was an independent invention, or whether Wirth was influenced by Richards's work.
Of course, the JVM and CLR are descendents of this, but they build a very complex structure on the basic idea. Writing an implementation of one of these virtual machines is not for the faint of heart.
So I think Bedrock can be very useful as a compiler target, if nothing else. However, I must agree with some of the other commenters that the 64KiB address space makes it very much of a niche tool. Come up with a 32-bit variant that's not much more complicated, and I think you have a winner.
We take this for granted now, but at the time it was revolutionary. In part, we've done things like mandating Unicode and IEEE 754, but nowadays most of our languages also encourage portability. We think very little of moving an application from Windows on x86_64 to Linux on ARMv8 (apart from the GUI mess), but back when Cobol was being created, you normally threw your programs away (“reprogramming”) when you went to a new machine.
I haven't used Cobol in anger in 50 years (40 years since I even taught it), but for that emphasis on portability, I am very grateful.
As for microarchitectures, for the most part those have evolved over the last 50 years. If you are looking to extract the last bit of speed out of a CPU, the only complete resource is the documentation. But pipelines and caches have heen around for a long time, look at the System/360 Model 85 and 91. A C programmer can use a fairly primitive conceptual model of a microarchitecture to get a pretty good first-order approximation of performance issues.
I am not saying that we should teach undergrads with 1980s materials. I am saying that a good understanding of pretty much any assembly language can get a programmer pretty far.
(Remember Bill Atkinson's famous response, quoted here to how much code he'd written that week: -3000. He had reworked Quickdraw so that it was faster and better, with a net loss of 3000 lines of code.) Of course the classic Mac had its own constraints.
Remember, there's a gigabit pathway between server and browser, so use as much of the bandwidth as you need.
I don't really pine for the days of the PDP-8, when programmers had to make sure that almost every routine took fewer than 128 words, or the days of System/360, when you had to decide whether the fastest way to clear a register was to subtract it from itself or exclusive-or it with itself. We wasted a lot of time trying to get around stringent limitations of the technology just to do anything at all.
I just looked at the Activity Monitor on my Macbook. Emacs is using 115MB, Thunderbird is at 900MB, Chrome is at something like 2GB (I lost track of all the Renderer processes), and a Freecell game is using 164MB. Freecell, which ran just fine on Windows 95 in 8MB!
I'm quite happy with a video game taking a few gigabytes of memory, with all the art and sound assets it wants to keep loaded. But I really wonder whether we've lost something by not making more of an effort to use resources more frugally.
It doesn't matter what architecture one studies, or even a hypothetical one. The last significant application I wrote in assembler was for System/370, some 40 years ago. Yet CPU ISAs of today are not really that different, conceptually.