Marcel Schramm

Asciinema Support For My Blog!

marcelschr@protonmail.com (Marcel Schramm) — Mon, 03 Feb 2025 00:00:00 +0000

I often want to have console output in my blogposts. Since I don't want to upload videos, due to their size, I just create code boxes.

However, I thought it'd also be cool to use asciinema, but I didn't want to rely on their servers. Thankfully you can embed the player JS and selfhost the files!

While the API is a bit awkward, as you manually have to inject the components into `div` elements, it does work like a charm.

To embed an asciicast into a blogpost, all I have to do now, is this:

Which is then automatically turned into this:

This partially happens at generation time and partially at runtime. The goal is to avoid loading any additional JS or stylesheet if possible.

JavaFX - Fixed Popups

marcelschr@protonmail.com (Marcel Schramm) — Thu, 18 Jul 2024 00:00:00 +0000

I am currently working on a small autocompletion text field. I want the component to show a small popup with completion possibilities whenever any are available at the current cursor location.

I thought "That's gotta be easy, just call new Popup() and invoke show() ... well, it didn't work too well. The popup would initially show correctly, but also not hide clicking anywhere. This is due to the fact you have to set `autoHide` to `true`.

After setting autoHide, it would however hide when you move the window or click in some area that can't receive focus anyway. This means the text field would still have focus, but no popup showing. This is quite annoying, as this means we can't bind the popup visiblity to the focus. While a workaround would be to listen to KeyEvent and MouseEvent to re-show the popup, this is janky.

Time to make my own popup I guess? I found an interesting post guiding me the right way.

This solution would allow me to freely place any component inside of a Pane. The only issue with this solution, is that it changes the bounds of the popups parent. So our hierarchy Would Be Pane(TextField, Popup).

To solve the layouting issue, the following rough setup is required:


            final var textField = new TextField("I am a TextField");

        final var popup = new Label("I am a Popup");
        popup.setVisible(false);
        popup.setManaged(false);

        final var pane = new Pane();
        pane.getChildren().addAll(textField, popup);
        pane.maxHeightProperty().bind(textField.heightProperty());
        pane.maxWidthProperty().bind(textField.widthProperty());

        showPopup();

Calling setManaged(false) on the popup will prevent it from being layouted, but also prevent it from expanding the parent in size. Since the parent is now bound to the size of the textField, we won't be pushing other components in the layout. However, since popup isn't being layouted, it does not have a position. While the methods setLayoutX and setLayoutY exist, they have no effect, as we are effectively not part of a layout. Instead we need to call setTranslateY and setTranslateX:


            private void showPopup() {
            popup.setVisible(true);
            final var textFieldBounds = textField.getBoundsInParent();
            popup.setTranslateY(textFieldBounds.getMaxY());
            popup.setTranslateX(textFieldBounds.getMinX());
            ...
        }

In order to show the text field, we need to always bring all components in its hierarchy to the front, as the popup will otherwise render partially behind other components in any nested layout. However, calling Node#toFront will actually reposition the nodes. Instead, we set the viewOrder to a negative value for the full node hierarchy:


            private void showPopup() {
            ...
            toFront(popup);
        }

        private void toFront(Node node) {
            node.setViewOrder(-1);
            if (node.getParent() != null) {
                toFront(node.getParent());
            }
        }

I hope someone can make use of this wild hack 😀

Dear Recruiters

marcelschr@protonmail.com (Marcel Schramm) — Sat, 11 Feb 2023 00:00:00 +0000

Every now and then I get E-Mails (or messages on certain services) from a recruiter. Most of the time, these people are very unlikable.

They act like you have a super interesting profile, even though you don't. They won't look at the work you've done, neither the professional work, nor the open source stuff. They won't care about what you've configured the preferences for your next job to be, they don't care about what you like or dislike. They don't care what city you want to work in, whether you want to work remotely (or in an office, like me) or whether you aren't interested in full-time offers. They don't even care whether you've ignored their previous 20 messages. They also try their hardest to get your telephone number, so they can annoy you every now and then.

At some point, one of them even called my (back then) employer and told them I talked to them about a job change and that we had an appointment, which was simply untrue.

Please give a shit about the people you want to hire :)

Go lacks enums

marcelschr@protonmail.com (Marcel Schramm) — Sun, 20 Sep 2020 00:00:00 +0000

As a Java programmer, I heavily make use of enums. The reason is quite simple. Whenever I have a fixed set of values, i can easily iterate over them and switch over them. The reason why I really like switching over enums though, is that I am using an IDE that notifies me of every switch that doesn't handle all possible values of an enum. Let's say I had the following Java code:

public enum CarManufacturers {
  FIAT,
  FORD,
  MERCEDES,
  OPEL;
}

void someFunction(CarManufacturer manufacturer) {
  switch (manufacturer) {
    case FIAT:
      //SOMETHING
  }
}

I would get an error stating that a switchcase I had wasn't handling all possible values and doesn't have a default case either. For those who don't know, the default case is basically a catch-all case for that can be used as a last resort. While switch-cases over enums are technically not exhaustive in Java, probably because of being able to technically extend an enum via reflection, the IDE still treats it that way. If you extend an enum at runtime you deserve to burn either way.

So, the value that this provides to me, is that I can extend an enum and be notified of all code pieces that need work.

Now let's look at Golang. In Go we don't have enums. The idiomatic go way for such things appear to be type aliases and the iota keyword.

For example:

type CarManufacturer int

const (
    Fiat = iota
    Ford
    Mercedes
    Opel
)

var Gotcha CarManufacturer = 5

func someFunction(x CarManufacturer) {
    switch x {
    case Fiat:
    case Ford:
    case Mercedes:
    case Opel:
    }
}

This creates the constants Fiat to Opel, incrementing their value by one starting from 0. However, as you can see, I can manually create another value with the same type. The problem is, that anyone can basically do this. So you never know whether you get some weird and unexpected values at runtime. While you can still handle those with a default case, my problem here really is the lack of static analysis and warnings. As the compiler basically can't know whether you've handled all cases.

Java RMI - Better error handling and performance with lambdas

marcelschr@protonmail.com (Marcel Schramm) — Fri, 19 Jun 2020 00:00:00 +0000

Even though Java RMI is already very old and has some problems, there are still a lot of application that use it. While some applications have no time, money or resources to migrate away from RMI, others might not be able to migrate away, due to the fact that the RMI-Stubs they consume are external services or whatever.

In the product that I work on, we use quite a big RMI-API in order to do synchronous communication between client and server. Our structure is however not optimal. Services are split into topics, such as Project or User. Each Service has a server-side interface and a client-side implementation of that interface that catches RemoteExceptions. Sadly all our try-catch constructs pretty much look like this:

try {
  Service.lookup(Service.class).method(parameters);
} catch( RemoteException exception ) {
  logger.error("Ooopsie woopsie!!!11!!");
  return null;
}

So ... not very useful. The problem with this is, that we can't really handle any errors that occur during the actual method-call, such as ConnectException. Well, it could, but it'd require tons of boilerplate for every method that you ever want to be able to call. As it is now however, the call would silently fail and return and incorrect return value which we can't differentiate from a correct return value.

However, we do handle errors that occur during the lookup of the RMI-stub. But technically another error could occur between retrieving the stub and calling the method on it.

Another problem with this approach is, that looking up the stub is actually a network call as well, meaning each RMI-call has at least doubled latency, ultimately dragging down the performance by a lot.

Finally the most annoying part about the solution, was that we had to write these boilerplate methods to be able to use the RMI-methods at all.

However, behold the lambdas!

Using lambdas we can easily do both the error handling, the call-retrying and won't have to write as much boilerpalte. While lambdas clearly take a bit more memory, I think it's worth the lower pressure on the network.

The interface is rather simple. We have two methods, one for calling methods that don't return a value and one for the ones that do. For the sake of keeping this post a bit smaller, I've simplified it a lot:

public static synchronized  ResultType get(
  final Class serviceClass,
  final ServiceResultFunction methodcall,
  final int amountOfRetries)
{
  try {
    ServiceType service = lookupServiceOrGetFromCache(serviceClass);
    return methodcall;
  } catch ( ConnectException exception ) {
    //Clearly the code doesn't make sense like this, but you get the gist.
    if (amountOfRetries == 0) {
      throw new ConnectionFailedException(...);
    }
    get(serviceClass, methodcall, amountOfRetries-1);
  } catch ( RemoteExcception exception ) {
    //Business Exception
    throw new RuntimeException(exception);
  }
}

public static synchronized  ResultType get(
  final Class serviceClass,
  final ServiceResultFunction methodcall.
  final int amountOfRetries )
{
  ...
}

Now you can call any of your RMI-stub-methods without having to write additional boilerplate:

User user = Services.get(UserService.class, userService -> userService.findByID(4));
System.out.println(user.getRegisteredDate());

I hope this will help someone in the future ;)

Don't be sorry

marcelschr@protonmail.com (Marcel Schramm) — Sat, 14 Dec 2019 00:00:00 +0000

Something I have noticed in the open source community and also in myself specifically, is that people feel guilty for things they don't do. You haven't answered that issue from a week ago, just because you didn't feel like it? You forgot fixing that terrible bug in that library you started making for fun, but others started relying on? You don't feel like keeping up work on a certain thing anymore or heavily slow down your pace? Don't feel sorry! You are doing all of this in your free time. YOUR free time.

Users of software, whether it's end-user applications, libraries or whatever, will always have expectations. However, YOU don't have to meet these. You haven't signed a contract, you aren't being paid and you probably haven't promised anyone anything.

While I want to believe all of this myself, I find it to be very hard. However, feeling bad won't help me or anyone else for that matter.

git reset --hard isn't that hard

marcelschr@protonmail.com (Marcel Schramm) — Fri, 29 Nov 2019 00:00:00 +0000

Like the experienced git user that I am, I accidentally deleted some of my code. I did this by running git reset --hard HEAD^^. I meant to only insert one circumflex, but that key acts differently on windows than it does on linux. Sadly I am already way too used to the linux behaviour, which only inserts one circumflex after hitting the key twice.

After a short search on StackOverflow, I found out, that reset doesn't actually drop a commit. Instead the branch will just stop tracking that commit. Meaning that you can still access the commit, as long as you still have the commit-hash or you can try finding it with git reflog.

After reading the man-page for git reset this also makes sense, since all that git reset is doing, is to modify the index and optionally your working tree.

However, this is even more interesting, when you are deleting a branch. A branch is really nothing more than a chain of tracked commits. So even after deleting a branch, you can still find the commits in the reflog. And simply git cherry-pick whatever you need.

Installing Fedora 31 on a Macbook Pro 2014

marcelschr@protonmail.com (Marcel Schramm) — Sun, 17 Nov 2019 00:00:00 +0000

The last time I decided to install something else than Mac OS on my Macbook, I decided to install an arch-based distribution. My choice was Antergos, since it was basically an easy installation of arch, but without additional software and all the good stuff, I guess. For my DE I decided to use i3, which was a pre-installation option at Antergos. However, the whole thing was somewhat painful, as there were a couple of unfunctional-by-default things:

Backlight (Changing / Restoring)
Brightness (Changing / Restoring)
Wi-Fi (Even after installing the driver, I still had connection issues)
Bluetooth (Even after getting the driver, it was horrible)
No system-wide scaling
No thermal management

While all of that was kind of annoying, it was somewhat manageable, but stuff like the brightness changing at some point even broke during an update.

Now, behold Fedora!

Fedora 31 comes with Gnome 3.34+ which has recently seen a lot of improvements. Out of the box, everything except for the Wi-Fi just worked. Getting the proprietary Broadcom 4360 driver needed to be done via a custom package. Besdides that, the only other thing I had to change was the fn-mode key, which I swapped from 1 (always pressed) to 2 (Never pressed). Two of the FN-Keys are dead, but I don't even know what they were for. Dead meaning that they are just not bound to any function by default.

Besides those two little itches, there were three other welcome suprises. Those being that the scrolling direcrion was "correct" by default (the Mac way) and the screen brightness automatically adjusts according to the light sensor. The best of those three, was probably the fact that scaling just worked out of the box. Both the Gnome UI and application all seemed to scale correctly. In the past, this was, in my opinion, one the major weaknesses on the Linux desktop.

Oh and sadly, the Bluetooth had stutters as well. This was due to interferences with 2.4Ghz Wi-Fi and could be temporarily fixed by swapping over to 5Ghz. This issue might be fixable by changing some settings, but I don't care for now, as I don't really use Bluetooth.

The only other nice to have thing so far, would be the nice touchpad gestures that you get by default in Mac OS. Especially the basic ones like pinch to zoom were really pleasant to use.

So far, it seems like Fedora will be the daily driver for my MBP.

Don't refork a GitHub repository every time you want to contribute

marcelschr@protonmail.com (Marcel Schramm) — Sun, 14 Jul 2019 00:00:00 +0000

Sometimes people contribute to one of my projects, and every time that they want to contribute, they delete their fork and fork the project again.

They usually do this because they don't know how to easily get an up-to-date master branch again. Since it's much easier to just hit "delete" and "fork" again, that's what they do instead.

However, this problem usually occurs when people start working on the `master` branch instead of a branch specifically made for their PR.

So the next time you want to work on a fork of some project with the intent to contribute your changes via a PR, do the following instead:

# Clone your fork
git clone git@github.com:/you/project
# Add the original repository as a new remote
git remote add original https://github.com/someone/project
# Now you'll have the remotes "origin" (fork) and "original" (original)
# We assume that your current master branch has no exclusive changes
# Now update your master using the originals masters state
git pull original master
# Now that you have an up-to-date master, create a new branch of that
git checkout -b your_new_feature
# This creates a new branch called `your_new_feature` and checks it out
# Now start implementing your feature and commit the changes.
# When you are done, push your changes to the fork
git push --all origin
# --all will push all branches to the remote
# Now create your PR via GitHub. As soon as it gets accepted into
# master, you can repeat the same procedure starting at
# `git pull original master`

This way you won't have to worry about both remotes having different commits, merge commits or whatever, since all your changes happen on a throwaway branch anyway.

In case you already have a poluted master branch, you can do the following:

# Check the originals master out
git checkout original/master
# This will bring you into a "Detached HEAD" state, meaning you aren't on a
# branch, but on a specific commit you could say.
# Now delete master locally
git branch -D master
# After deleting master, we use our current state to recreate it
git checkout -b master
# Now we'll locally have an up-to-date master
# Now we push, but we need to apply `--force`, since our commit will delete commits that already exist upstream.
git push --force

I hope this helps ;)

If you have an easier way of doing those things, leave a comment!

About offloading work to the client

marcelschr@protonmail.com (Marcel Schramm) — Mon, 13 May 2019 00:00:00 +0000

I have been working on an open source Discord client for a while, it uses the official REST API and tries to reproduce the features of the original electron client. When I got to the point where I could actually chat, one of the first things I tried, was sending emojis. Well, didn't quite work out. When I entered emoji-sequences like :cry: or :sunglasses:, all I got back was plaintext. But why is that, if the original client converts all those sequences into actual Unicode characters? This is simply due to the fact, that in order to implement this feature, Discord uses client-sided business logic. So before sending the message to the server, for example:

What a great day :sunglasses:

It converts the message into this:

What a great day 😎

This feature works on the desktop-client, the web-client and the mobile-client. However, my client couldn't do it, since the server doesn't do this thing, even though the behaviour is supposed to be the same across all devices (clients).

There are other scenarios though, where even the official Discord clients differ in their behaviour. Take a look at the commands that the client suggests you when you type a /. The desktop-client and the web-client will show you a list of available commands and allows you to chose one of them. However, the mobile client does nothing at all, since it doesn't support a single of those commands. Not even simple ones like /shrug, which simply inserts a shrugging kaomoji into the message. But hey, who needs consistency, am I right ¯\_(ツ)_/¯?

So what if the Discord team decides that they want to write an additional client at some point? Maybe a native desktop client that doesn't use electron. Well, they'll have to replicate all client-sided behaviour in their new client, which means additional time consumption and therefore additional cost. On top of that it increases the margin for error. If you write the same code twice in different languages, maybe even with different testing and whatnot, you might end up introducing errors in one version of the code, but not in the other. On top of that, maintaining the code becomes harder, since changing the behaviour on the client means having to change it twice.

Most likely they have a reason to not implement such behaviour on the server-side though. One of the most obvious reasons would be lowering the workloads on the server and therefore reducing the amount of money needed in order to run the backend infrastructure. Even though such a simple feature sounds trivial and like it wouldn't cost much performance, think about how many active users Discord has that send messages every second. Eventually for a big service like Discord it might just pay off.

The next time you implement business logic, you might want to ask yourself the following question:

Does it technically matter where I implement the behaviour? Iff not, what are the benefits for each decision and how much weight do those benefits have to me personally?

My own approach is usually to avoid writing business logic more than once, since it usually just introduces more work in the long-run. As it shouldn't be a problem as long as you don't have scaling problems, whether due to money restrictions or hardware restrictions.

VPNs and the lies you are being fed

marcelschr@protonmail.com (Marcel Schramm) — Sat, 11 May 2019 00:00:00 +0000

Today I'd like to talk about VPNs, despite the fact that many people have probably already told you the same thing that I am about to tell you.

So, I have noticed that recently a lot of YouTubers are advertising VPN services. Those are usually PIA or NordVPN. The promise usually made in those advertisements, is something along the lines of "Privacy due to full encryption of your traffic". Now that sure sounds great, right? Err ... not really. While encryption would prevent someone from reading or manipulating your data, you can't simply End-To-End encrypt any traffic.

Usually when you make a request over the internet, you (the client) create your request and target some other machine (the server), that lies somewhere else. Since you are not directly connected to the server (in the same local area network), your request has to be routed over the internet, meaning it will hop from device to device, trying to find the most efficient route to your requests target.

So yes, the VPN could theoretically encrypt your request before sending it to the server, however, this would break the request, as the server could not decrypt it. So what actually happens, is that the VPN receives encrypted traffic, which it then decrypts and forwards to your actual target server. Now, usually that traffic is already encrypted, as most traffic nowadays is HTTPS.

So, what does this mean in the end? It means you don't really achieve privacy just by using some VPN service.

Some people actually get a VPN in order to hide their malicious activies from third parties that could potentially track them down. Does that at least make sense? Yes, kinda. The original location of the request will not be known to a third party. However, they can still ask your VPN who you are or where you are. And I doubt you really want to trust some random company that promises you full privacy for just 2.99€ a month. However, using the VPN to access some service that has geographical restrictions or get around blockades that your government has put up, a VPN is still fine. Even though a simple proxy would probably do the job, unless your government does deep packet inspection.

Let's not get started talking about free VPN services, like the one that facebook offered (or still does?). They obviously don't do this because they want to keep everyone from reading your precious traffic.

Anyway ... back to the YouTubers! It's a shame that strong social media presences advocate for something they don't seem to understand much about. If they'd really care about their audiences, they should not advertise such services or at least inform themselves a bit before doing so. In order to prevent such false advertisements.

EDIT:

Someone has pointed out to me that those YouTubers are being paid for making those advertisements in their videos. I was well aware of that when writing the post, however, I didn't feel like this would be worth mentioning, because even if you are paid for something, that doesn't mean you should lie, not inform yourself or abandon all your values.

Be careful when moving files within a git repository

marcelschr@protonmail.com (Marcel Schramm) — Fri, 19 Apr 2019 00:00:00 +0000

So, today I learned something interesting about git that I have been doing wrong way too often without even noticing it.

Imagine the following scenario:

You have a file called hello.go, it greets the user with the very simple and static sentence Hello user.. At this point and time the commit history for the file looks like this:
~/code/hello (master)$ git log --follow hello.go commit 03c325f415ca2418fa9bf9f759ca1fc16f50c8e6 (HEAD -> master) Author: Marcel Schramm Date: Fri Apr 19 19:11:06 2019 +0200 Add initial implementation that simply greets the user with a static sentence.
Next you decide that a static greeting is quite boring and unpersonal. So you now have new requirements. The application should greet the user differently depending on the current daytime. The greeting it uses between 6am and 11am should be Good morning user.. Starting at 12am til 5pm it should use Hello user. and starting 6pm it should use Good evening user.. On top of that it should be able to take the users name via a parameter that can be passed on startup. So you rewrite your code accordingly.

Now you decide that a more fitting name for this file would be greeter.go, since it doesn't simply say Hello user. anymore, so you rename it:
~/code/hello (master)$ git mv hello.go greeter.go
Your changes were made and your file has been renamed. Now you wanna commit this, so you add your new file to the staging area:

~/code/hello (master *+)$ git add greeter.go

Finally you commit:
~/code/hello (master +)$ git commit -m "Rename hello.go to greeter.go, since it is more fitting. Change output depending on the daytime and optionally accept a username." [master d003cc6] Rename hello.go to greeter.go, since it is more fitting. Change output depending on the daytime and optionally accept a username. 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 greeter.go delete mode 100644 hello.go
Fine, you are good to move on! Next day you wanna see the history, so you call git log on your greeter.go file:
~/code/hello (master)$ git log --follow greeter.go commit 33a3c028ef060c600164f0f7c7757012426f319c (HEAD -> master) Author: Marcel Schramm Date: Fri Apr 19 19:29:26 2019 +0200 Rename hello.go to greeter.go, since it is more fitting. Change output depending on the daytime and optionally accept a username.
Since, there wasn't enough similarity between the old file and the new file, git didn't really notice that this is still the same file, but with different contents. Since git mv is basically just an alias for git rm and git add. So if you only were to do small changes, this might work fine. Anyway, you will still have all changes in your full repository history.

In order to prevent this loss of file history you simply have to first commit the rename of the file and then do your changes. Never do renaming and changing of the content in one commit.

But we have full test coverage

marcelschr@protonmail.com (Marcel Schramm) — Wed, 27 Mar 2019 00:00:00 +0000

I often see people claiming that their tests are as good as they could get, since they have full (100%) test coverage. And obviously 100% coverage is as good as it could possibly get. Or is it not? You guessed it, coverage isn't everything, The quality of the tests plays a big role as well.

Here is a little example of full test coverage that isn't very useful:
package testme var ( someMapping = map[int]string( 1: "Hello", 2: "World" ) OutOfBoundsError = errors.New("Out of bounds") ) func Something(input int) (output string, err error) { if input > 0 { return someMapping[input], nil } return "", OutOfBoundsError } package testme_test func TestSomething(t *testing.T) { result, err := Something(1) if err != nil { t.Error("result should've been 'Hello', but an error was returned") } if result != "Hello" { t.Errorf("result should've been 'Hello', but was '%s'", result) } result, err = Something(2) if err != nil { t.Error("result should've been 'World', but an error was returned") } if result != "World" { t.Errorf("result should've been 'World', but was '%s'", result) } result, err = Somethng(0) if err != nil { t.Error("call should've returned an error, but it didn't") } }
This code will test all statements, meaning that it will have full coverage. But it won't test all theoretically possible cases. When calling Something with 3, we will get an empty string instead of the expected error, since accessing a non-existent key in a map will return the types default value.

If you wanna test this out for yourself, go ahead and run this:
package main import "fmt" func main() { wow := map[int]int{2: 4} fmt.Println(wow[1]) }
So whenever you write a test, don't look at the code coverage first, instead pay attention to whether you have tested all possible cases. However, if a function doesn't have full coverage, that is probably an indicator for cases that aren't handled or even useless code.

What do I think about Go

marcelschr@protonmail.com (Marcel Schramm) — Thu, 13 Dec 2018 00:00:00 +0000

I have been doing Go for a while now and so far I have enjoyed it. Why do I enjoy it though? First, let's look at my past!

I have been doing Java for three years now and I can't say that I am happy with it any more. In the beginning I really liked Java, but over time that has changed.

Here is a list of stuff that annoys me:

Long start-up times

You actually need to have Java on your machine (or ship a JVM)

The JVM nags on your ram

NullPointerExceptions everywhere

It's verbose

For every primitive an object type exists

more...

The next language I looked at was Kotlin. Oh boy, Kotlin is so fun! It has tons of cool features. After a while I stopped using Kotlin as well though, since it still runs on the JVM and has it's own problems.

I still keep an eye on Kotlin native though.

Then someone kept shilling Go. After a while, I thought I should just give it a look. When I started getting into Go, I have noticed a few things that I really liked. It was very easy to get started. There is an interactive online tutorial that teaches you the basics and afterwards you just download Go and get started. You don't have to get a build-tool, you don't have to get a dependency manager and you don't have to get a test framework or something like that. Go comes with all those tools built-in, which is what makes it really fun and easy to get started.

Besides having all those tools built-in, it is also super easy to learn the language itself, since it doesn't really have many features and a rather simple syntax. You don't even have to think about formatting and such, as you won't even be able to compile if the compiler doesn't like the way your code is formatted.

Overall the language has a nice ecosystem, including it's community, just like in Java, you'll almost always find an answer to your questions.

I don't think I like Go because it is such a revolutionary and good language. I think I just like it because it is so easy to get started without any frustration whatsoever.

However, I am not saying that Go is perfect, just like Java and Kotlin, Go has it's own problems.

Here are some things I dislike about Go so far:

nil, which means there are also nil dereferencing errors

No generics (Those would be super handy)

No really good IDE yet (VS Code / Goland come closest to an okay experience)

But who knows, maybe I'll start disliking Go as soon as I start any bigger projects, which means that I'll probably face bigger problems.

Think Twice Before Using Varargs

marcelschr@protonmail.com (Marcel Schramm) — Tue, 11 Dec 2018 00:00:00 +0000

Varargs, which is short for variadic arguments, are a pretty cool thing. They allow your functions to take from 0 to n arguments, the amount of possible function arguments might differ from language to language though. Most of you have probably already used a function which makes use of varargs. Throughout this blog post, I am gonna use Java for examples.

As an example, let's look at String.format(String, Object...):
String name = "Marcel" String.format("Hello %s.%nThe weather is quite good today.", name);
The resulting String would look like this:
Hello Marcel. The weather is quite good today.
We could also use the function to just add a line break, but pass no additional variables:
String name = "Marcel" String.format("Hello.%nThe weather is quite good today.");
This would still compile, since varargs allow from 0 to n arguments, which is totally fine for our use case though.

But let's look at a more dangerous example:
class Screamer { /** * Screams each passed word onto a new line. * * @params words are the things to be screamed */ void screamWords(String... words) { for( String word: words ) { System.out.println("Scream: " + words.toUpperCase()); } } } class IntenseScreamer extends Screamer{ @Override void screamWords(String... words) { //Intensify the words by adding exclamation marks! for( int index = 0; index < words.length; index++ ) { words[index] = words[index] + "!!!"; } super.screamWords(); } }
In case you haven't noticed the error, I forgot passing the words to the supercall. That happens quite easy, since it allows 0 arguments as well. In such case, an empty array will be passed, since varargs are nothing but arrays under the hood.

I am not telling you to avoid varargs completely, but sometimes you might just want to use an array, as it will give you some compile-time safety, since you have to at least pass an empty array.

In my opinion, you should avoid using varargs if you could potentially pass an incorrect amount of values, since there can not be any compile-time checking without using third party tools.

This actually happened to me at work, which is why I bring it up. I wasted a while before I found the problem, since I didn't check every place where the parameters were passed on. I just knew that nobody mutates them and I knew that they were passed correctly in the beginning, so why the hell was I getting an empty array.
EDIT:
A colleague pointed out that it might annoy some people to always create arrays, which is kind of the reason why varargs are so nice to use. A possible solution to that problem would be a mandatory parameter followed by a vararg parameter of the same type.

Here is an example:
//Defining your method void hello(String nameOne, String... restOfNames) { String names[] = new String[restOfNames.length + 1]; names[0] = nameOne; System.arraycopy(restOfNames, 0, names, 1, restOfNames.length); //Implementation... } //Calling it hello("Marcel", "Jeff", "John"); As you can see, this requires some additional logic, but it would usage wise be the same for the methodcaller, unless the intention was to actually pass a complete array, in that case the caller would have to create a new smaller array and pass the first cell of the old array as the first parameter. This would also be worse performance wise, even though this would usually not be critical.

Why do people expect software to be for free?

marcelschr@protonmail.com (Marcel Schramm) — Thu, 15 Nov 2018 00:00:00 +0000

Recently I have been wondering why everyone seems to expect software to be free. Free software has existed for quite a while, but many people have started to expect software to be free by default.

I assume that many people think that the software they use in their daily life is already free. Let's take Facebook as an example. Do you think Facebook is free? Yes, it is free to use, however, this doesn't mean that you aren't paying in a way. When using Facebook you are paying with your personal data and you are probably seeing ads, unless you are using an ad-blocker. By the way, even some ad-blockers aren't completely free, some actually mine data or only block ads that they aren't paid for. The same goes for other free-to-use software that you use.

In case you are interested in using an ad-blocker, I suggest you take a look at UBlock Origin.

Okay, so what do we pay for? We pay for games, right? Buying a AAA game for 60€ still seems to be accepted by most gamers. However, would they buy a 5€ game for their smartphone? Unlikely. I have noticed that many people seem to expect smartphone apps to be free (subsidized by ads) or extremly cheap. Why do many people deem 5€ for a smartphone application to be much? I assume this is due to the fact that smartphone apps feel more like a "side thing" that you just use in order to keep the boredom away. There are also apps that don't focus on entertainment. As far as I know, those kind of apps are less used by the average smartphone user though.

Do I pay for mobile applications? No, not really, the only app I have ever bought was Teamspeak 3 and I refunded it, since it was terrible. However, I do not like to use applications that are subsidized by advertisements, because I believe that the advertisement model is completely broken. Applications that implement an advertisement model often decrease in user experience. Either by showing popups, using up the space on your screen or even adding trash to your devices system. I generally believe the way that most advertisements are made today, is very dishonest. Whenever seeing an advertisement on the TV, I feel like I am being lied to.

In order to avoid such subsidation models, I try to use as much truly free software as possible, also referred to as free open source software. However, people should be paid for the work they do, right?

Yes, everyone should be paid for the work they do, at least I believe so. So, what can you do? I suggest you start to try using more free open source software and if you like what you are getting, drop a donation from time to time, it really helps! Some software projects are actually completely subsidized by donations, for example an operating system called Elementary OS. It has adopted the `pay what you want` model, meaning that if you want to, you can just not pay anything. The system also has a software store that allows you to optionally pay for anything that you install via the store. Such principles are viable and are being used, however, most companies still try to maximize their outcome by any chance and therefore such things will unlikely ever be adopted by big companies.

Another good payment model is the one that League of Legends is using. You can download and play the game for free, however, you can still purchase ingame items in exchange for real money. Those ingame items don't provide the player any advantages over the other players, since they are only visual items. Those items can be skins for characters or emoticons and ward-skins. League of Legends has been doing it this way for a long time now and it seems to work just fine.

EDIT: Someone just pointed out that you could also buy champions(playable characters). In the beginning you only have a specific set of characters. Until season 6 or 7 it was quite hard to get many characters in a short amount of time. At a certain point they made it much easier though.

So, what's the point of this post? I'd like to encourage you to start paying for software. I assume just like me, many of you are annoyed by advertisements, especially looking at mobile aplications and websites. If more people were to pay for software and media, then less companies would decide to start build their products around an advertisement model. I am not telling you that you have to use free open source software though, that's just my opinion. However, think about paying for what you use, because just like the machine that you use for reading this post, someone had to produce that software.

Food for thought: Why do you think that no one expects physical goods or services should be free?

A Month Into Solus Budgie

marcelschr@protonmail.com (Marcel Schramm) — Sun, 27 May 2018 00:00:00 +0000

A while ago I decided to start abandoning proprietary services, one of those was windows.

Backstory

The first Linux I had ever seen and actively used was open SUSE in 2011 I believe, I was about 13 years old at that time.

I was just a "normal" user and solely used it to play games and surf the web. At some point I stopped using SUSE ... I forgot why, but probably due to me being too stupid to achieve what I wanted to achieve. I then switched to Windows 7 and used it for about 3 to 4 years and then decided to get Ubuntu, at that point and time I had to abandon all the games that I had played on windows. I missed my games and switched back to windows 7 after about 3 months. As soon as Windows 10 was available I did the free upgrade and was quite satisfied, since Windows 10 fixed a lot of the quirks that Windows 7 had:

Flat Design

Multiple workspaces (desktops)

windows snapping with proper multi monitor support

It was faster

more ... (I am too lazy to list more)

on the other hand it introduced some annoying stuff, like builtin advertisements in the startmenu, preinstalled bloatware, annoying popups and additional telemetry that you can't easily disable. Also they started to replace more and more of old Windows 8.1 and below GUI with their new fluent design GUI ... which to be honest is worse in my opinion. Well ... enough talking about windows.

Solus

In the beginning I decided to go with open SUSE due to the fact that it was the first linux I had ever seen and used. After only 3 days of pain (KDE 5 Plasma constantly crashing) I switched to Solus.

Just like open SUSE, Solus wasn't based on another big distro, like Ubuntu is based on Debian. One downside was, that I can't use any .rpm or .deb packages (at least not by default). On the other hand we have Snap and Flatpak nowadays, which provide a way to easily install software across different linux distributions. Most of the software I needed was available in official Solus repositories, those are quite up-to-date, sadly they are lacking some old and common stuff like xterm, simply because there is no need for it.

I really hate waiting, which is why I am happy that Solus starts up quick, logs you in quick and even shuts down lighting fast.

I actually don't use much operating system features, but neither did I use much operating system features when I was on Windows though. I just need a minimal OS, which is fast, up-to-date and looks good, Solus satisfies all of those needs in my opinion.

Budgie

Solus is available with different desktop environments:

Gnome

Mate

Budgie

I decided to go for Budgie, simply because it looked minimal and well designed. I also wanted to try something new. Overall I like Budgie.

It comes with some Windows 10-like Notification center, called Raven which also integrates media playback:

and easy access to your audio input and output devices:

It also supports system tray icons by default, unlike Gnome nowadays.

It has an application menu for listing and grouping installed applications, the Budgie Menu, sadly i have experienced heavy problems with said component, which is why I deactivated it and use the run command prompt instead. The run command prompt only allows you to type in a name and execute one of the search results. Back on Windows 10 I only ever used the start menu to do exactly that, so I am not missing out on anything here.

Budgie has some Gnome integration and ships with some of the default gnome tools. I am not the biggest friend of the gnome tooling. As I already mentioned I used KDE for a short while, I really loved it, especially the file manager (Dolphin), which had terminal integration and multi pane support and the terminal (Konsole) which supports horizontal and vertical tiling.

Budige comes with Nautilus, which doesn't support the two features I like about Dolphin, so I ended up deleting Nautilus and am now using Caja, which is a fork of the old Nautilus (back when it still had features). I first tried using Dolphin, but sadly it didn't work that well without the KDE desktop.

I removed gnome-terminal and replaced it with Tilix. I went for Tilix due to the fact that it supports tabs, horizontal and vertical tiling and easy customization of keybindings.

Gaming

Okay, let's talk about the actually important stuff ... playing games! I bet you all know, that windows is usually the best choice for gaming, sadly I can't deny that fact.

However, Solus allows easy installation of 32-bit and 64-bit NVIDIA drivers, reducing the initial problems a lot. And by using Lutris, you can easily install a lot of different Windows-only games.

Lutris can manage games for different platforms:

wine

native Linux games

Linux Steam

Windows Steam

Browser

and a couple more

allowing you to easily manage your game library using a single application.

You could also manually install the native Steam client via wine, but I would suggest using Lutris if possible, as you’d have to do all the dependency management for the games yourself otherwise and probably you’d even have to create two wine prefixes, one for 64-Bit Steam and one for 32-Bit Steam.

Solus allows you to install the native Steam client via eopkg, its integrated package manger, in addition to that, it also offers improved integration for steam.

Back on windows I played a lot of different games:

Dark Souls 2

Dark Souls 3

Dishonored 2

Warframe

Heroes of the Storm

Hearthstone

League of Legends

Brawlhalla

Battlerite

CS:GO

Fortnite

Osu!

Insert bunch of indie games here

Except for some of the indie games and CS:GO, those are all non-linux titles.

It is no problem to run low graphics games like, Brawlhalla, League of Legends or Hearthstone via Wine, but games like Dark Souls, Dishonored or Fortnite aren't playable unless you have very powerful hardware.

Even though I have a GTX 1050 TI, I am unable to play Warframe, Dishonored, Heroes of the Storm or Dark Souls via wine.

Currently, those are the Windows-only games that I got up and running (putting native Linux titles aside):

League of Legends
I am using the OpenGL version with low graphic settings, since directX9 causes heavy client bugs

Brawlhalla
Has lags sometimes, but runs fine most of the time.

Battlerite
Runs fine with directX9

Hearthstone
Might not run perfect at all times, but it is a card game, so it doesn’t really matter

Osu!
Runs fluid and my Tablet (Huion H420) also works. In order to easily add new songs to the song directory, I use the mv command as my default application for .osz files.

And those are the ones that I didn’t get to work:

Heroes of the Storm
This really surprised me, the game had pretty stable fps of 120+, but the fps dropped to 0 for a moment, as soon as any character used an ability. Since using abilities is what you do the whole time, the game was simply unplayable.

Dark Souls 3
I don’t know why, but the game simply didn’t start, I might investigate this further at some point.

Fortnite
Since Fortnite uses BattleEye anti-cheat, which doesn’t work with wine, this game can’t be played.

Warframe
Well, it works, but only at unstable 40 fps on minimal settings, which is no fun

Conclusion

I can recommend Solus for daily usage. Most people might not be as picky about their file manager and terminal as I am, so that shouldn't be something that most users would have to mess with.

Probably Solus shouldn’t have been my first choice though, since I obviously preferred the tooling that KDE 5 Plasma gave me, but sadly I had already lost trust in it after seeing how buggy it is on open SUSE Tumbleweed and open SUSE Leap. I didn’t feel like wasting my time to give it a third try.

I have probably just scratched the surface of what might be important to some people, sorry for that.

If you find any mistakes, like wrong information or typos, feel free to submit a pull request.