bakatubas

Well it’s hard to say at the scope of world powers. Maybe small, local governments there’s less. But let’s be honest here, and consider the atrocities of yesteryear. They span the gamut, and they span democracy through authoritarian regimes. The only difference is how it’s conveyed/portrayed to citizens, and how quickly /easily it is for any single party to gain control of a nation.

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.

All forms of government no matter how big or small are fcorrupt. That’s how it works—they/them who bends the will of the masses wins. Either that’s done by manipulating folks into believing the next candidate will “take their pain away”, or by inflicting pain for non-compliance. Or they change the rules: voter suppression, censorship, etc and pretend they “won the election.” Or they just murder the opposition and blame it on Santa Claus.

> In short, what would this be used for?

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

Of course each situation can be unique. I wouldn’t recommend staying at any place that overworks employees or unfairly compensates them.

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.”

This might be true in tech world but in local economies does not make sense. How can folks “switch jobs” every two years when there may not be equivalent opportunities in many cases?

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.

Nowadays everything is layers on top of layers. File systems from regular partitions and RAID to LVM then to ZFS/Btrfs. Virtualization of OS systems to KVM/Qemu to containers.

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.

And then pee on the floor and do jumping jacks, run in circles, then read a magazine, then install an upside-down lectern in the living room only to realize... you forgot the television.

God save us all!

Honestly all websites should support a no-script, static version to prevent 90% of the webs BS. We used to be able to view sites with JavaScript disabled and actually things would work.

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?

Man—all I can say is most tech companies suck these days in that way. Bought a Samsung “smart” tv and a couple months later got an update—now it’s showing McDonalds ads. Like WTF I paid $500 for a TV but that’s not good enough?

The ad industry is a cesspool these days.

I second that—memories installing gentoo on iBook G4 and getting the wireless to work felt like a nice accomplishment :)

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

The first computers filled up an entire room and look where we are now...

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

The web is the way for universal exposure. Regardless of speed it’s the only standardized, universal and widely used interface.

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 can’t argue _for_ any particular tool—just that the concept is a really good concept.

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.

Absolutely! That is similar to artists doing thumbnail sketches to figure out the composition; then once things are reasonably worked out, the chosen composition can be worked onto the final canvas; then the details follow.

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.

Honestly, I think complex architectures are best demonstrated as diagrams—and those can be developed in an agile fashion. Stable, well-thought-out architectures can’t be slapped together without nice diagrams. There’s a ton of folks who just “start coding” to get a feature going, but when someone else takes over the project, how are they to learn the code? Diagrams are always the best way for me—and there’s limits on what doxygen says, depending on how bad the implementation is.

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.

I dunno I disagree—the fact is a lot of people just dive into coding and don’t spend much time with design.

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.

All the more reason for folks to spend more time using the debugger; for instance, break points are only one feature.

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.

As a counter-point, I think there’s an argument that folks don’t spend enough time in the debugger. But there’s a lot of value there and in fact one could use a debugger environment to unit test as even native debuggers have scripting environments.

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.

It makes sense for software release versions, but I think this lacks marketing prowess.

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.

I think that is true regarding language popularity—but not their viability for intended purpose.

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 :)

I found a vulnerability!

...

Just kidding. :)

Is that because folks are pooping in the rivers? You’d think folks could just catch rainwater. Sounds like an infrastructure issue...

Or mandate 2FA and password managers.

Agreed. But still, folks make it sound bad. For instance “danger” in the many context could also be reframed as “powerful”, could it not?

Unfortunately, as is most always the case of negligence instead of some particular language features:

“A commission attributed the primary cause to general poor software design and development practices rather than single-out specific coding errors. In particular, the software was designed so that it was realistically impossible to test it in a clean automated way.“

Ergo, concurrency doesn’t kill people, people do.

I don’t get this obsession with “dangerous.” Honestly, what does that even mean? I think a better word is “error-prone.” Danger is more like, “oh my god a crocodile!”

In addition, it tells folks how much available content. And you can eyeball an action like “go to approximately 80% down the page.”

Personally I think these should have a legal license associated with them. Like if the author transfers NFT it transfers the creative license as well (so the purchaser actually owns the art). For instance, Nayan Cat beanie babies can now only be manufactured by owner of said token, and whenever the new owner transfers the token the license goes with it. Etc.

Basically, if Token == Intellectual Property ownership then it makes sense.

This would mean if a creator, say a musician wrote a song and transferred the NFT and it became a wild success in the future, the owner would earn profits from the investment, but so too would the content creator receive the mentioned dividends proportional to the value.