Only has the functionality that you need, everything is obviously in its place. Runs incredibly quickly without using a lot of resources, and then gets out your way when you’re trying to do stuff. No settings hidden away because they might confuse novice users. No bullshit shoehorned in by managers.

Apart from the ugly font rendering, this might be as good as the Windows UI ever got. WinNT looks the same and has almost incomparable stability improvements, but only if you’ve the right hardware to run it. WinXP starts the downhill slide with ‘appearance over functionality’ and the hot mess of the control panel.

I could live with how OP has things set up here; my own copy of Plasma doesn’t look a million miles from this.

I’m in this photo and I don’t like it.

More specifically, my programming background is in industrial automation and I’d like to add some more ‘robust and flexible’ algorithms to CoolerControl so I can control my system fans / temperature better, but it’s written in a mix of TypeScript and Rust.

I’ve spent 20 years programming hard real-time z80 assembly and know quite a few higher-level languages. (Although I prefer the lower-level ones.) Not those ones, however, so it’s not just a couple of hours work to raise a PR against that project. Going to need to crack some books.

I understand that things have changed a bit since I first moved over to Linux - moving from Red Hat Linux to Ubuntu ‘Warty Warthog’ was such a revelation in overall user-friendliness and usability, back in the day. But upgrading my graphics card from an NVidia one to an AMD was a similar change. I might have only just installed the base operating system and a desktop environment and haven’t got around to a web browser yet, but I’ve already got full hardware accelerated graphics - that’s crazy.

Most distros now make the NVidia drivers a complete non-issue, I think? My 6600XT is requiring just a few too many compromises on new games, so I’ll need something new too, sooner or later. I used to hold off on graphics cards updates until I could get something twice as good so that it was a noticeable upgrade, but I could buy a pretty decent second-hand car for all the ones which are ‘twice as good’ now.

An upgrade from a 1050 Ti shouldn’t be such a problem. Well done on keeping it alive so long - I had a GeForce GTX 970 that would have been a similar age, but it let out its magic smoke years ago.

Moved my father-in-law from Windows 10 to Mint.

Biggest problem was all his ‘documents’, which were office365 web links rather than ‘actual documents’. Linux presents them as the urls that they really are. They open just fine, though, and can be exported as real local docs for libreoffice etc.

Security and privacy were the main selling points for him. He’d done some reading and thought that Mint was among the best choices for a newstart that just want everything to work; no interests in playing games or anything. I agreed that was the most solid choice. I use Arch btw myself, but wouldn’t recommend that for beginners.

Centrally managed repositories help a lot, here. Linux users tend not to download random software off of sketchy websites; it’s all installed and kept up to date via the package manager.

Yes, Linux malware and viruses exist, and we shouldn’t pretend otherwise. The usual reason for installing Linux virus scanners is because you’re hosting a file/email server, and you want to keep infected files away from Windows users, tho.

Mark Z. Danielewski for the win. House of Leaves is superb; 50 Year Sword is interesting, but doesn’t quite scratch the itch. I see he’s got something new out this year as well, will need to check it out.

Vim is my preferred ‘IDE’ for C++, Python, Bash, and general configuration file editing. It’s got some big pluses:

• its text editing is superb once you’ve mastered it, but that’s a small part of its benefits when used as an IDE, and ‘Vim mode’ in other environments kind of undersells what else it can do

• Vim has some great plugins for development. YouCompleteMe is awesome for predictive completion and showing docs, but NerdTree for file management and TagBar for showing structure are amazing as well. They’re all very configurable and they get out of your way.

• Vim lives in your terminal window, so you can do splits and tabs using whichever terminal you like. Kitty is very fast and configurable and keeps out your way. Being able to have multiple tabs of Vim open, a tab for compilation, a tab for debugging, a tab for version control, a tab for man pages, and being able to flip between them without taking your fingers off the keyboard makes for a very fast workflow

• Vim makes it very easy to edit binary files and be precise about whitespace changes, so it’s easy to make a minimal change for raising a PR.

If you assign a hotkey to run a macro in Vim, then that can be made very flexible - saving and formatting all open windows, then invoking CMake to do a build and CTest to run all your unit tests can be put on a function key if you like. Trying to tell Eclipse to “just run CMake to do the build” seems to be an exercise in frustration; so many IDEs are terrible at “just getting out of the way”.

Work pays for an IntelliJ licence for using Java. Java is so unwieldy without a proper IDE that it’s hard to code in it without it. I certainly don’t love it, though, and they seem determined to make every new version worse with bizarre new features. Flexible minimalist editing with configurable plugins is all that you really need, and on that basis Geany looks pretty good - will give it a try.

Allows the very important ‘overwrite files while they’re open’ functionality used during update. Write all the new files for a service then restart it. No need to reboot the whole machine for that.

Looking at you, Windows, and your bullshit scheduled reboots.

I’m still trying to make ‘sloppers’ happen. Perfectly describes the lack of thought that goes into what they produce.

You can turn off “delete”, but modification is a danger, it’s true.

Turning off delete makes it excellent for eg. backing up photographs on your phone. I’ve got it doing this from my Android to my raspberry pi, which puts them on my NAS for me. Saves losing all my pictures if I lose my phone.

What you can achieve in a couple of pages of Python can be pretty spectacular. It’s also mostly very easy-to-read, with the possible exception of class inheritance, which is confusing mess.

If you need to write more than a couple of pages, then its lack of types becomes a hindrance to me - doing refactors when functions can take basically any arguments is quite painful, for instance. Not requiring any particular structure is great, up until you start to struggle with lack of structure.

Ideal programming language for when you’re wanting to do something that would be a bit too unwieldy for a shell script. It also makes network requests and json parsing very straightforward, so it’s great for interacting with REST APIs and writing simple microservices. Fast to write and runs quite quickly, so a good choice for Advent Of Code-like tasks. Would probably choose a different language for larger projects or when working in a team, though.

I learned z80 assembly back when the cutting edge of technology was a ZX Spectrum, and 68k assembly when I upgraded to an Amiga. That knowledge served me quite well for my early career in industrial automation - it was hard real-time coding on eZ80’s and 65c02 processors, but the knowledge transfers.

Back in the day, when input got mapped straight into a memory location and the display output was another memory location, then assembly seems like magic. Read the byte they corresponds to the right-hand middle row of the keyboard, check if a certain bit is set in that byte, therefore a key is held down. Call your subroutine that copies a sequence of bytes into a known location. Boom, pressing a key updates the screen. Awesome.

Modern assembly (x64 and the like) has masses of rules about pointer alignment for the stacks, which you do so often you might as well write a macro for it. Since the OS doesn’t let you write system memory any more (a good thing) then you need to make system calls and call library functions to do the same thing. You do that so often that you might as well write a macro for that as well. Boom, now your assembly looks almost exactly like C. Might as well learn that instead.

In fact, that’s almost the purpose of C - a more readable, somewhat portable assembly language. Experienced C developers will know which sequence of opcodes they’d expect from any language construction. It’s quite a simple mapping in that regard.

It’s handy to know a little assembly occasionally, but unless you’re writing eg. crypto implementations, which must take the exact same time and power to execute regardless of the input, then it’s impractical for almost any purpose nowadays.

Enough of that crazy talk - plainly WheeledDeviceServiceFactoryBeanImpl is where the dependency injection annotations are placed. If you can decide what the code does without stepping through it with a debugger, and any backtrace doesn’t have at least two hundred lines of Spring boot, then plainly it isn’t enterprise enough.

Fair enough, though. You can write stupid overly-abstract shit in any language, but Java does encourage it.

Succinctly and well put.

Well now. My primary exposure to Go would be using it to take first place in my company’s ‘Advent of Code’ several years ago, in order to see what it was like, after which I’ve been pleased never to have to use it again. Some of our teams have used it to provide microservices - REST APIs that do database queries, some lightweight logic, and conversion to and from JSON - and my experience of working with that is that they’ve inexplicably managed to scatter all the logic among dozens of files, for what might be done with 80 lines of Python. I suspect the problem in that case is the developers, though.

It has some good aspects - I like how easy it is to do a static build that can be deployed in a container.

The actual language itself I find fairly abominable. The lack of exceptions means that error handling is all through everything, and not necessarily any better than other modern languages. The lack of overloads means that you’ll have multiple definitions of eg. Math.min cluttering things up. I don’t think the container classes are particularly good. The implementation of pointers seems solely implemented to let you have null pointer exceptions, it’s a pointless wart.

If what you’re wanting to code is the kind of thing that Google do, in the exact same way that Google do it, and you have a team of hipsters who all know how it works, then it may be a fine choice. Otherwise I would probably recommend using something else.

I feel that Python is a bit of a ‘Microsoft Word’ of languages. Your own scripts are obviously completely fine, using a sensible and pragmatic selection of the language features in a robust fashion, but everyone else’s are absurd collections of hacks that fall to pieces at the first modification.

To an extent, ‘other people’s C++ / Bash scripts’ have the same problem. I’m usually okay with ‘other people’s Java’, which to me is one of the big selling points of the language - the slight wordiness and lack of ‘really stupid shit’ makes collaboration easier.

Now, a Python script that’s more than about two pages long? That makes me question its utility. The ‘duck typing’ everywhere makes any code that you can’t ‘keep in your head’ very difficult to reason about.

Frezik has a good answer for SQL.

In theory, Ansible should be used for creating ‘playbooks’ listing the packages and configuration files which are present on a server or collection of servers, and then ‘playing the playbook’ arranges it so that those servers exist and are configured as you specified. You shouldn’t really care how that is achieved; it is declarative.

However, in practice it has input, output, loops, conditional branching, and the ability to execute subtasks recursively. (In fact, it can quite difficult to stop people from using those features, since ‘declarative’ doesn’t necessarily come easily to everyone, and it makes for very messy config.) I think those are all the features required for Turing equivalence?

Being able to deploy a whole fleet of servers in a very straightfoward way comes as close to the ‘infinite memory’ requirement as any programming language can get, although you do need basically infinite money to do that on a cloud service.

No love for the ‘declarative’ programming paradigm? You can actually do some useful work with SQL or Ansible…

A binary tree is one way of preparing data, usually for sorting. Each node can have a left, right, or both, children.

  A
 / \
B   C
   / \
  D   E

“Inverting the tree” means swapping the children for each node, so that the order that the nodes are visited is reversed. Depending on whether you want to copy the tree or swap it in place then the algorithm is different. C++ provides iterators too, so providing a “order reversed” iterator can be done efficiently as well.

You’re going to have to visit every node and do at least one swap for every node, and an efficient algorithm won’t do much more than that. Bring unable to do it suggests that the student programmer doesn’t understand stacks or recursion yet, so they’ve more to learn.

Programming a robust global date-time system and having a transparent conversation between metric and *imperial/traditional" units is just a warm-up to show that you can work with the truly demented currency system. Make sure everything is rounded off to the nearest whole ha’penny.