Yup. If you call a function with the C calling convention with the incorrect number of parameters, your cleanup code still does the right thing. With the Pascal calling convention, your stack is corrupted.
As much as I love emacs, I think cut and paste is better metaphor for text editing than kill and yank. Once the key combos are part of muscle memory, the value of mnemonics goes down, but they're very useful for adoption. This is an unfortunate barrier for emacs beginners. Even though the usual CUA keystrokes are available (and even the defaults on some popular starter configurations), the terminology creates some friction when reading the docs.
I agree the semantics are strictly superior though.
There were no words for this stuff. People just made it up, and it took years for something to emerge as the de facto standard term for a collection of data persistently stored.
There's an interesting parallel with the emacs editor. Operations we now universally call "Cut" and "Paste" are "Kill" and "Yank". The better terms won out and emacs is stuck with Ctrl-K and Ctrl-Y as not-so-intuitive mnemonics for cut and paste.
One of the great things about C64 BASIC and similar MS BASIC derivatives is it's extensibility. It defines a bunch of pointers, including $0033 this article uses, that control the memory layout. Manipulating them carefully allows you to free up blocks of memory that BASIC won't trash. Or deliberately "trash" for hacks like this.
On top of that, a handful of key internal BASIC routines are called indirectly through pointers. BASIC itself is in ROM and more or less immutable, but by redirecting those pointers you can have it call out to new code in RAM.
Did some development for a server application that supported RS/6000 among other platforms. AIX on RS/6000 was a nice enough Unix but, being used to Solaris, everything seems just slightly off. I think it performed slightly worse for the same price as Sparc hardware for our purposes, but some customers wanted an all IBM solution (we also supported an OS/2 client).
The main thing that stands out was a tool (smitty?) that could do system configuration and IIRC it could show you the steps to do it manually as well.
This is exactly how I feel about Dune. The invented words and world-building are overwhelming at first, but once you absorb them it makes the narrative richer.
Two of my favorites, too, although I'd go with Anti-Fragile from Taleb.
I think Anathem is Stephenson's best. The Diamond Age is also really good. For every one of his books, I just wish he could write an ending that matches the quality of the rest.
The core of this a library called nsync. It appears most of the improvements by Justine are upstreamed into nsync itself which doesn't have any of the baggage of cosmopolitan. Whatever your opinion of the project or author, they've made good effort to not lock you in.
I second this. OIDC is much nicer and my experience using it with federated identity sources through AWS Cognito was smooth. The sad reality is that SAML is already entrenched in many enterprise environments and unavoidable.
When I had to figure out how to add SAML authentication to a custom application, I built a barebones, no-framework Java application[1] just to understand the webflow. A good way to understand it is to just set up your own IDP like Keycloak running locally and play around with it.
More than half of Canada's coal production is metallurgical coal, suited for steel production. Most of that is mined in BC and exported. The grandparent comment and the above response are both true.
Playing cards in some parts of Europe have alternate suit symbols. Spain and Portugal use clubs, swords, coins and cups. My favorite aspect of this deck is that the clubs symbol is an actual club weapon instead of the usual clover.
You're probably right. There's a lot of code for those processors that's not going away.
Too bad though, the 6809 is the pinnacle of 8-bit CPU architecture. It's the result of analyzing the practical shortcomings of the 6800 and other CPUs and redesigning the ISA. It has 16-bit index registers and 16-bit arithmetic, addressing two of the 6502s most annoying drawbacks. Additionally, it has support for stack based locals, position independent code and a LEA instruction. All those make building a high level language compiler much easier than other 8-bits.
I own a Gakken GMC-4 microcomputer, which appears to be a remake of the FX-System. It's a fun little 4-bit computer with a hex keypad for input. For output, there's 7 LEDs, 1 7 segment digit lcd, and a speaker.
It has 16 instructions, one of which is an escape code to a further 16 built-in IO routines. It has 96 4-bit words of actual memory plus some memory mapped registers. Loads and stores can only target the data segment, the top 16 words in memory; it has one 4-bit wide index register that allows indexed access as well.
It's a fun challenge to do something interesting in that constrained environment, but since there's no non-volatile storage of any kind, you have to tediously key in (admittedly necessarily short) programs each time it's powered up.
It's been a while since I've run with that configuration, but setting the variable server-use-tcp to non-nil enables it. On startup, the server creates a file with the connection details that emacsclient can consume. I think it just works if the filesystem is shared between client and server machines but command line options allows the use of a copy on the client.
I don't run emacs in a terminal emulator. Emacs is my terminal emulator. All my terminal programs get run in a (graphical) emacs shell-mode buffer. The rare program that needs full screen control uses term-mode.
It's not the most featureful or fastest terminal emulator, but I can jump around the buffer like any other buffer and seamlessly access it along with the other content I'm editing.
On a remote computer where I can't run a graphical emacs, I either remotely edit files via tramp, or run a headless emacs server process and connect remotely with a graphical emacsclient.
Make's killer feature was conditionally rebuilding based on changed dependencies. Back in the day, it was easy for a medium to largish software project to take many hours, or even days to fully rebuild. C and C++ were especially bad, especially "every file transitively includes every header" type projects. Make saved a lot of that pain, even if linking still sucked.
I love make and still spin up a minimalist Makefile like in the article regularly for tiny projects, but I'd hate to have to actually maintain one for a real world project.