It would certainly be weird, after their recent games were so story-driven. You can’t tell a good story, if you need to always keep the end open for possible expansions.
It would certainly be weird, after their recent games were so story-driven. You can’t tell a good story, if you need to always keep the end open for possible expansions.
Yeah, and they often launch with loads of systems where future content could be plugged in, but the actual content itself is typically bad or at the very least incomplete. The publishers try too hard to build a platform rather than a good game…
Yeah, theoretically the exact model for monetization isn’t as important, but many publishers are hoping to get players to pay subscriptions indefinitely.
I’m not expecting insane test coverage. What I’m looking for, is that they’ve understood that writing tests makes their (future) life easier, too. A hobby project can benefit from that just as well. I’d argue almost even more so, because you might be working on a feature over the course of several weekends, where you’ll benefit from having written down the intended behavior at the start.
Fucking hell, man, with how many very publicly visible security problems they had last year, you’d think the stakeholders would be on board with doing security for a bit.
Personally (as a dev), I wouldn’t particularly care that you know a specific library (the chance of us using the exact same library is pretty slim and will probably change when the project changes). But I would care to see that you are using a library when it makes sense.
So, if you implemented a hashtable yourself and I spotted that, I’d remember that as you either not knowing that that’s called a “hashtable”, so you didn’t find a library for it. Or I might think that you’re potentially stuck-up, thinking you can do a better job implementing it yourself.
The aspects I’d look for, starting with the most important:
Wanna check if a variable’s set to something expected?
if [[ <test goes here> ]]; then <handle>; fi
Hey, you can’t just leave out “test goes here”. That’s worst part by a long shot.
The rest of the syntax, I will have to look up every time I try to write it, but at least I can mostly guess what it does when reading. The test syntax on the other hand is just impossible to read without looking it up.
I also don’t actually know how to look that up for the double brackets, so that’s fun. For the single bracket, it took me years to learn that that’s actually a command and you can do man [
to view the documentation.
Yeah, sometimes I’ll use that just to have the sane control flow of Rust, while still performing most tasks via commands.
You can throw down a function like this to reduce the boilerplate for calling commands:
fn run(command: &str) {
let status = Command::new("sh")
.arg("-c")
.arg(command)
.status()
.unwrap();
assert!(status.success());
}
Then you can just write run("echo 'hello world' > test.txt");
to run your command.
To be honest, I wish sometimes Rust had an optional GC mode (I know this would be against the principles of the language… don’t take this wish too seriously).
If you just need the occasional cop-out, you can wrap a value in an Rc
or an Arc
. They do reference-counting, which is almost like garbage collection (reference counting can’t resolve cycles between references).
I’ve got basically the bspwm workflow, but on KDE.
So, bspwm has tiling of windows and doesn’t want you to minimize (nowadays, it actually has a minimize-feature, but back when I last used it, it didn’t). As a result, if a window is open, it is visible on some workspace. If you want to hide windows, put them on a different workspace.
I like that workflow, because while it probably seems complex when you first hear about it, it actually simplifies things. When you’re looking for a window, you don’t have to check all the workspaces and minimized windows and behind other windows.
KDE adds to that, in that I can have a workspace overview in my panel, so where I can see all workspaces with the windows that are visible on them (which with this workflow is all windows on that workspace). I like to call it my minimap.
It makes the workflow a lot easier to use, but it also allows me to group workspaces by location. So, if I’m working on a topic, I often have a Firefox window on one workspace, my text editor on the workspace below and then a terminal on the workspace below that. If I then realize, I need to quickly look up something for a related topic, I’ll open up a new Firefox window two workspaces below that (leaving an empty workspace as separator). If I do something completely different, I might leave a whole bunch of empty workspaces in between. Or, well, KDE actually allows grouping workspaces with a feature called “Activities”, so I’ll often switch Activities.
I find that works a lot better for multi-tasking than the traditional Windows workflow of one window per application, with all kinds of different topics mixed into all kinds of ungrouped windows. If I switch between topics, I just go to the right location on my minimap and I’ve all the topic-related information in the windows that are there.
And if you’re wondering, what the hell, if there’s no overloading, how do you even design an API???
You’ll learn about the From
and Into
traits, which allow you to take multiple types for a parameter, because those traits implement the conversion between those types.
Oh, so LibreOffice is actually a fork of OpenOffice, meaning back in 2010, the devs copied the code from OpenOffice and have been developing it further from there. So, it’s like your parents just got upgraded to the newest edition of the office suite they were using. A lot of it should still be familiar to them.
Basically, the devs had to change the name for legal/political reasons. In all other ways, LibreOffice is the continuation of OpenOffice.
OpenOffice
Most Linux distros come with LibreOffice pre-installed. That’s what you want. OpenOffice pretty much stopped being developed in 2010 and the developers moved over to LibreOffice.
Oh yeah, you can, but it makes it pretty much impossible to discern between commits in the action run overview. So, if something broke between one change and the other, then you’d have to just kind of know what that change was.
That is obviously doable, if you make a singular change, then wait for the result before you make the next change. But I often had the problem that I would get interrupted or that I had to continue on the next day, so when I wasn’t quite as clear anymore what lines I changed precisely. Or what also often happened, is that I would get bored while I’m waiting for the action run to complete, so I start making the next change before I know whether the previous change was successful (I guess, this only really starts to become a problem, if it takes 30+ minutes for the run to complete).
But yeah, I put them onto a separate branch, so I can easily squash them into one commit before putting them back onto the proper branch.
I’m not sure, I understand the question, because there’s tons of languages that are basically just a superset of another, such as C++ for C, TypeScript for JavaScript, Crystal for Ruby. Heck, the whole family of LISP languages kind of matches your question, because they all use most of the syntax of LISP.
The problem is that you end up using software that’s hosted on GitHub and then you’d like to report a bug or contribute a fix. You also don’t want to give your data to Microsoft. Both can be true, because the projects on GitHub don’t exist in isolation there.
There’s a comparison here: https://forgejo.org/compare-to-gitea/
Whenever I need to fix something with them, I go onto a separate branch, write a sane commit message once and suffix it with a “1”. Then the next time, I just grab the same git commit
command from my history and change the “1” to a “2”, then to a “3” etc…
Hmm, I don’t have experience with hosting Forgejo, but my intuition tells me that because it has relatively many features, that its administration is more involved than if you only host a Git Server.
You could then use a static site generator to turn your MD-files into a webpage. Personally, I have a (still very small) knowledge base webpage using mdBook, mostly because I was already familiar with it, but it’s also pretty simple to setup and has a built-in search.