I agree that some systems are better than others, and there is still hope for better ones to come. But let’s not kid ourselves into believing China has done anything terrible that the USA has not already done in spades.

A stepping stone to inventing new species, or augmenting humans with super-human powers… duh!

I am referring to tech folks arbitrarily switching jobs JUST for a pay increase, every year or two years. What’s left behind many cases is in maintainable code where people shrug it off as “someone else’s problem.”

I’d also like to point out that while many tech folks are just as fickle with their jobs as they are with programming languages, there is a lot of benefit to holding one’s post and trying to build a better company, too.

That being said at some places stagnation can happen and then it’s obvious to switch jobs, but stability can offer many benefits over arbitrary switching for more money.

Operating systems function now in general is to provide a means for running arbitrary systems on top of the metal. It’s astonishing what one can do with cloud-init and a base Linux install these days. I can botch up all the layers above and quickly restart without installing anything on the base system install.

Granted, there’s always special cases but I see that “stable core” over which anything can run to be the target. Just look at the M1 chip—designed to run virtualized architectures efficiently.

So, to reiterate my point, Operating systems should target virtualization/abstraction features as efficiently as possible so it doesn’t matter which OS or workload folks run, or where it’s running (cloud, IoT, desktop, laptop, server, etc).

An additional area requiring research is security. Process obfuscation of some kind to prevent tampering etc there are still work to be done.

God save us all!

Also, instead of arbitrary cookies why not standardize authentication/authorization security mechanisms to avoid having those stupid cookie pop ups.

At this point there are common web pattern which separates the essentials from the BS—so why not get rid of the BS and keep the good stuff?

The ad industry is a cesspool these days.

Granted, the gentoo docs are really good so that’s where I went mostly.

This is a proof of concept and surely it will be refined to make more efficient construction processes.

WebAssembly will be the ticket there—once it’s developed a bit more.

That being said, nothing compares to native. You could have shitty hardware by today’s standard with amazingly performant software if there weren’t so many damn layers in-between.

People are fickle with hardware though and we devs need things to slow down a bit to appreciate the nuances of each device!

I think a lot of it comes down to folks not bothering to invest in making good tools—or developers sticking to their current workflow.

That is why I relate it to Test-Driven Development because it does require a shift in process. But the end result, I think, could be very rewarding.

That is a nice benefit of good development frameworks: how easy is it to explore new ideas? And frankly that’s why there’s an uptick in higher level languages.

Main point of UML is to tackle both diagramming/architecture AND forcing basic coding to reflect the diagrams. It forces code and documentation to both reflect the architectural truth.

This doesn’t have anything to do with agile methodologies, as any task can follow agile workflow.

There’s a ton of value in the idea of diagramming code and then generating sources. UML is a starting point but the journey is far from over.

The more appropriate idea is that you create documentation in the form of diagrams for free. Just like in TDD you get unit-tests for free.

Folks always talk about self-documenting code—and that’s great. But what about conveying a complex system to a new team of engineers? Diagrams are frankly priceless if done well.

Also, looking at something like Kubernetes where a declarative YAML file generates magic underneath is somewhat similar. A step beyond what we have would be nice diagramming capabilities over the YAML to auto generate the plumbing underneath.

Personally, I think future advances in development _will_ be done as higher level ideas—pictures worth a thousand lines of code—AI will do the rest.

Setting up remote debugging I’ll agree is more difficult than a local application, but each remote machine can automatically run startup commands and not require user input; commands can be run at particular places too (to print output etc) with conditional trace points, all while not impacting the code itself.

Main point is that folks don’t spend enough time learning the debugger, as print statements are easier. But using the debugger is a better practice in my opinion in the case where print statements are added just for a quick test, then removed.

Personally, I think folks should master the debugger _first_ and during all steps learning a programming language.

But similar to test-driven-development it’s a different way of thinking, and most books scarcely discuss the debuggers.

That being said, I do use print-debugging a lot too—in C++ a lot of functionality can be compiled-out, allowing one to, for instance, print hex dumps of serialized data going to the network.

On that note, there is a distinction between trace debugging that is part of the source code and general print statements that are hacked in and removed.

Consider; “hey man check out my new M1 machine!” Versus: “hey man check out my M1 2021.04”

Even with the Core series it’s short and sweet.

“10th gen. Core i7” still sounds futuristic and always will.

Ryzen 7 also.

Honestly I think folks here are overthinking this stuff. It’s easy enough to compare the specs on a 10th gen cpu vs 8th gen. I think that’s easier than comparing different product names.

For instance, just by the names: Pentium 5 versus Core i5 it’s not quite clear unless folks were old enough to remember Pentiums. Whereas, everyone knows current generation has better processing than previous generation.

Perl is a great example because although it has its quirks and the ecosystem shows some age, there really isn’t anything like Perl. It is a very good language for interacting in the console and with data of many types. It’s $_ variable which is based on implied context (much like in language we short-form speech when context is implied). Those are features something like rust (or go) simply isn’t designed for.

Hell, people still use and enjoy programming in C or Basic or Pascal. They just aren’t “popular” because developers are eager to put their comp-sci to use and invent more languages :)