If gRPC overhead is critical to your system, you've probably already lost the plot on performance in your overall architecture.
You make a fair point about smart pointers, and median "modern C++" practices with STL data structures are unimpressive performance-wise compared to tuned custom data structures, but I can't imagine that idiomatic Java with GC overhead on top is any better.
He definitely made games. Chris Crawford was one of the first known names in game design, a few years ahead of contemporaries like Sid Meier whom I expect you'd still recognize. Crawford seemed to alternate between computer war games, with reliable prospects for commercial success in the 80s, and more experimental fare about managing nuclear reactors, geopolitics, and such - difference being he seemed to get bored by the whole thing and completely disembarked in pursuit of whatever it was he intended to achieve via Erasmatron, Storytron, etc. It's fascinating to read his writings over that period. It seemed a sort of tragic paradox overshadowing all of it that, if he was so bored of mechanistic, algorithmic, and predictable computer game mechanics, maybe stop pursuing computer games as your chosen medium? It may have been a blind alley in the end, but someone had to explore it.
Nevertheless, it is quite sad - however, it's difficult for me to relate to the experiences of someone who lived through that first wave of personal computing and played a notable part in it - perhaps through that lens, anything was possible.
The 8x16 font from the Atari ST's hi-res mode is pretty slick if you like something bold and a little futuristic.
https://github.com/ntwk/atarist-font (or rip it directly from the ROM)
It is of some practical use, but there are a lot of slightly incompatible versions of the IBM PC and of MS-DOG, so it doesn't offer the kind of strong reproducibility that I'm looking for.
A DOS-executable is far more write-once-run-anywhere now than Java ever was, and the best thing is that no one is going to ever deprecate any API in DOS. There is no software rot in a dead OS.
There's still a few Common Lisp features the mainstream would benefit from ripping off. Relevant here is the condition system. Conditions and restarts are still foreign enough that it's hard to explain to people why the "debugger" was a fundamental part of the lisp machine UI, and how much sense that made, and harder still to fathom how you'd adapt that to Unix, where it would morph into some kind of weird IPC tied into the command shell.
It's not just about being able to stop your program and hot-patch code to recover from errors - this should be trivial in any dynamic language. Rather, it's about being able to composably control how to recover from exception conditions (or, really, any branching behavior) both interactively and programmatically in a unified framework.
Today by, way of your screenshot, I discover Asm-Pro. Just got into Amiga recently (by way of receiving one from my uncle's closet..) and have been meaning to backfill my shameful lack of 68k asm knowledge. Thanks!
Good luck! As the sibling comment mentions, Asm-Pro is IMO a good choice these though it requires KSv2+ (so you can't use it on an stock A500). I mostly use vasm for "larger" stuff though (http://sun.hasenbraten.de/vasm/) and cross-compile (though it can run on Amiga as well) / test in an emulator.
For a quick test/code loop nothing beats the Asm-* family - remember to save often and make backups though :)
Oh, I don't know - in my (admittedly limited and very individual / company-specific) experience, the senior management was hard to relate to from the perspective of us rank and file, but clearly had the Sword of Damocles over their head at all times, and tended to get swept away arbitrarily every few years as the winds of corporate politics changes direction. It seemed to require some exceptional execution (or luck) to defer this cycle for even a year or two.
Depends what you mean by senior management, of course. I'm thinking mostly the "VP / SVP of Engineering" type role, and to a lesser degree, one hop down, the "Senior Director" folks, who seemed to be subject to the same phenomenon but on a slightly slower cycle.
The higher up the rank you go in my company, the more recognizable the faces are from 10,15,even 20 years ago.
Sure, they shuffle the deckchairs, but the turnover and redundancies below them is orders of more chaotic, and I dont understand what it takes to clean house at the senior management level.
My understanding is that all corporate positions above rank and file — and especially the C-levels — live in a meat grinder where the only viabile strat is "figure out how to kill competition on the corporate chaos/ladder before it kills you".
Of course this acts as a filtering mechanism to refine psychopathy and their decision tree about how to treat their labor force, the communities their corporations exist within, their customers, and even their investors reflect how they've treated people to get where they are already: exploit and discard.
Then again, these people always fail upward. They may have the sword hanging over them, but when the sword falls and they leave, they do so with a fist full of millions of dollars in Golden Parachute, and then float over to Level+1 at the next company.
Yeah, over my career I've seen multiple c-suite bounce from company to company getting gently pushed out each time but still collecting massive packages (with the vacation houses and yachts to prove it).
Once you reach a certain level, you get treated with kid gloves. Even with the sword hanging over you, they don't out right fire you, they work out a deal where you "wanted to spend more time with family".
It's because at a certain level you have valuable relationships people want to protect, enough wealth to make decisions without it personally affecting you in a real way (i.e. homelessness, loss of medical care, etc), and information about how the company "really works" that could be valuable to the competition or a tell-all story for the media.
Basically, if you're rich, you're a "real person" and if you're not you're an ant.
Well you don't get to those positions without handling metric buttloads of blackmail, and that's largely all a golden parachute really is: wealthy psychopaths caching out on all of the markers and dirt they have on everyone else when they leave. :P
From my perspective (for me, personally), the closing of Google Reader killed blogs. That's when I largely stopped reading them. Other readers seemed not worth the trouble, for various reasons. Was this before or after the onslaught of SEO slop? Seems like this shouldn't have been an issue in the age of RSS readers - why would you subscribe to blogspam?
Briefly, Twitter was a useful alternative to promote blog posts (the set of people you follow on Twitter not necessarily being that different than who you'd subscribe to via RSS), but then the blog hosting platforms themselves seemed to age into irrelevance while things like Medium and Substack appeared (neither judging nor endorsing them) while Twitter degraded.
I suppose you're right about Twitter to some degree, though anything that could fit in 140 characters probably belonged better there anyway.
But that's like half of computing.. every new tool the world inflicts on you, configured in Jojo's Awesome Configuration Language, with some arbitrary made up grammar punctuated by Tourette outbursts of special character line-noise.
That, or YAML, then a tool to template and generate the YAML, and then a stack of tools wrapped around that, ad infinitum.
A little learning is the cost of not having to write the thing yourself. On the other hand, hell is the non-composable tower of babel that is computing. Total employment by exponentially compounding incidental complexity.
The amount of arbitrary glue, configuration and "cool things" I need to learn-and-forget for every new project is an order of magnitude less than any other language I've used in anger.
The fact that people do it in the ordinary language, so you can click through to the operator definition and see immediately what it does, makes it a lot less taxing IMO. Even if the code is quite complex, figuring out what an actual function does is 10x easier than doing the same with a magic annotation, which is what you have to do in that situation in most other languages.
Right, now imagine the templated YAML mess implemented in Haskell together with the app. By someone smart enough to liberally use Haskell's most complicated features
You make a fair point about smart pointers, and median "modern C++" practices with STL data structures are unimpressive performance-wise compared to tuned custom data structures, but I can't imagine that idiomatic Java with GC overhead on top is any better.
reply