This post aims at explaining the basics of the JVM, while also giving more in-depth information for those who are interested in it, but always without getting excessively technical. In fact, even if most newcomers prefer getting their hands dirty by starting to code straight away, I believe that learning about the Java Virtual Machine is particularly important - to know what you are doing, to be better at optimizing (and troubleshooting) - but mostly, to avoid running into walls when trying to raise your level and competence. And also, because I think it's very interesting to learn about the engine that powers our applications.

The principle

The JVM is, by definition, a Virtual Machine. In other words, it is an abstract, virtualized computer with a very specific set of instructions. This definition, however, might bring a question to life:

So, can it run an OS such as Linux?

No, it can't. Not unless you develop a Linux emulator in Java, but that's not what we are considering. There is a fundamental difference between two kinds of virtual machines: system virtual machines, and process virtual machines.

System virtual machines

Those are your typical OS emulators: QEMU, VirtualBox, VMWare. They provide complete system platforms, by emulating existing architectures and thus allowing the emulation of a complete operating system.

Process virtual machines

This is where the JVM resides, alongside .NET Framework's CLR and others. PVMs allow running normal applications inside a host OS, and support a single process. They take life to spawn a process, and die when it ends. The purpose is to provide platform-independent environments, by abstracting the underlying hardware and OS, and allowing programs to run identically, independently from the platform. So, they adapt the codebase to run on any platform, without emulating the platform itself.

The JVM

The JVM, in particular, has the benefit of being supported by a huge variety of devices and hardware. This is because it is defined by a specification, maintained by Oracle. Everyone is free to make an implementation of that specification, and effectively produce a new JVM that can run bytecode. Thanks to this, there are multiple implementations, such as OpenJDK and Jazelle.

Back to general VMs

As you can already tell, process and system VMs follow the same abstraction principles, but implement them in vastly different ways, to address different needs. We can say that a process VM (or multiple ones) can run inside a system VM, and clearly not the opposite.

While system virtual machines are general-purpose ones and, nowadays, they are even used dynamically to allocate resources and manage different services in medium to big corporations (see: Proxmox), process virtual machines are very specific and limited to a certain scope: executing a program.

The argument could be a thread of its own, spacing from hardware-assisted virtualization to the roots of VMs in the CTSS. However, we are just trying to analyze and understand virtualization as how it is applied to Java, and this was a necessary premise to give a wider view and a general idea.

The structure

The process of developing and running a Java program follows a very specific and invariable flow, which can be expanded and enriched (eg. by Maven, deployment, obfuscation...). We are going to skip everything that happens between you writing code, and the JVM creating a process to run it, since this post's purpose is to explain the JVM and we don't want to get off-topic. Basically, it consists of:

1. a developer writes human-readable Java source code by using an IDE;
2. a compiler "translates" this code to bytecode;
3. the bytecode is sent to a JVM that creates a process and runs it.

The class loader

As we already stated, Java code (Main.java)  is converted into bytecode (Main.class). The bytecode is then sent to the JVM's class loader.

Loading

The class loader subsystem is responsible for translating - yet again - the bytecode into binary data, which is then saved in a space named method area. The stored information consists of the class' fully qualified name (net.mindoverflow.tutorial.Main), the type of the class (class, interface, enum) and all of its methods, variables, constants. For each .class file, the JVM creates a java.lang.Class object that represents that particular class in memory. This allows usage of the getClass() method, that we can then expand with, eg., getName(), to get the class' fully qualified name; getSimpleName() that just returns the class' name, and so on. Since we don't want ambiguity and redundancy, but also to avoid a number of related issues (which one should we reference to?), only one single Class object is created and stored in memory for each class.

Linking

The linking phase consists of three other steps: verification, preparation, and resolution.

Verification serves the purpose of ensuring that the .class file has been properly generated, before actually compiling it to binary. If the file is malformed or badly formatted, the Bytecode Verifier component throws a VerifyError runtime exception. Else, the file is ready to be compiled.

Preparation prepares the class for usage: the JVM allocates memory for all of the class' variables and sets them to the default values.

During the resolution step, all symbolic references to methods, classes, interfaces... are replaced with direct references. This is done by querying the method area and locating the referenced entities. This is particulatly complex and many errors can be thrown, but for the scope of this article, this is enough. If you want to understand it more in depth, here's the official Oracle specification.

Initialization

This is the final step of the class loader. All static variables are assigned to their vaules specified in the code, following hierarchy (from parent to child) and order (from top to bottom). At the end, all classes are ready to be used. Or technically, what we have extracted from those classes, since we won't be running the .class files themselves.

Class loaders

There are three kinds of class loaders:

1. Bootstrap loader: this is the core class loader, used by the JVM to load trusted classes such as the core Java API ones found in the JRE library. The JAVA_HOME/jre/lib/ directory is known as the bootstrap path, and it is implemented in native languagaes such as C and C++.
2. Extension loader: this loads other classes in the ext/ (JAVA_HOME/jre/lib/ext/) subdirectory in the bootstrap path, and thus, it is a child of the bootstrap loader.
3. Application/System loader: finally, this loads all classes in the application's classpath, and it is a child of the extension loader.

JVM's memory

Memory is clearly the foundation of any running software, and the JVM has a very specific structure for handling temporary things.

Method area

We have already referenced the method area earlier. Here, all class-level info is stored: class and parent class names, variables (including static ones), methods. There is only one method area for each JVM instance, and it is shared.

Heap area

As the method area, this too is unique per each JVM and shared. It contains info about every object of the running program.

Stack area

This is not shared: for each thread, the JVM initializes a runtime stack and stores it in the stack area. Every stack is made of blocks, and every bock of each stack is named a record or frame, and traces method calls. Every local variable of those specific methods is stored in their relative record. When a thread is closed, the runtime stack is deleted too.

Program counter registers

The JVM supports multi-threading, and every thread has its own pc register. Each thread is always running a specific (and single) method. The pc register contains the address of the JVM instruction currently being executed if the method is not native. If, instead, the method is native, the address is null.

A native method is a method that is developed and runs in a language different than Java, while non-native methods are Java methods. Native methods are used to access system functions that can't otherwise be accessed by the JVM. However, they limit portability of an application, because they are platfom-dependent.

Native method stacks

In addition to all the previously described memory structures of the JVM, an application could still use other data, created by (or for) native methods. This is because the JVM has very little control over what native methods do, since they are not encapsulated under it, but ran separately. When a thread invokes a native method, it runs in a separate "world" from the JVM, without any kind of restriction. Clearly, then, native method stacks can't be inside the JVM's stack area, and thus, a new native stack is created, and the JVM links dynamically to that method. If the native method is, for example, a C method, then its stack will be a C stack, and not a Java one. A native method interface will, most likely (although it depends on its purpose and how the developer personally decided to implement it) be able to call back into the JVM, and invoke a Java method. In this case, the thread leaves the native stack and enters another Java stack.

Execution engine

The execution engine is what makes everything move. It reads the bytecode in the .class files line by line, and after querying the various memory areas, it compiles and executes the given instructions. It is made of three parts.

The interpreter

The interpreter reads and verifies the bytecode, and then executes it. This is nice because it doesn't require compilation, but one of the main disadvantages of the interpreter is that if a method is called multiple times, it has to be interpreted each time.

The JIT compiler

The just-in-time compiler complements the interpreter: it compiles everything into native code, and when the interpreter notices repeated method calls, it provides precompiled code to run, thus avoiding re-interpretation and increasing efficiency.

The garbage collector

The garbage collector has the purpose of deleting unreferenced objects. An unreferenced object is any object that has been created, but not stored anywhere, and thus "lost" in memory. This happens, for example, every time you create an instance of something in a method, and then quit the method without storing that instance somewhere (in a List, a Map, ...) and without manually destroying it. The GC is a pretty complex matter, which we'll talk about in another post.

Conclusion

This is pretty much everything you should know about the Java Virtual Machine, especially if you previously knew nothing about it. I understand that some things may be a little complex - specifically if you're just getting started - but don't worry. If you grasped the main concepts, you are already ahead of a big part of developers out there. You don't need to remember or understand everything I wrote here, specially if you are a developer and you don't work daily with the JVM specification. And if you, instead, do work daily on implementing the Oracle specification, you probably even know better than me and this was just a fun quick thing to read.

Either way, I hope this was an interesting thing to read and that I was able to make you learn something new and interesting.

See you soon!

Having a sidebar that allows your visitors to get a general idea of the post's structure, and to skip and freely navigate to any point, is a nice little addition that can make the reading experience more clear and interactive. You can see an example of it in the left sidebar of this website, as long as you're not on mobile.

Creating such a component is really simple and requires a few lines of code, as long as you're already using jQuery on your website (which is very likely). If you aren't, you'll just need to import it.

Importing jQuery

This is easy. Just add the following code between the <head></head> tags of your blog posts:

<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
</head>

Remember to replace the 3.5.1 version string with the latest version of jQuery. It won't be a problem for now, but in a few years it might begin to be a little outdated.

Structuring your post's HTML

If you want to have a fully functional sidebar, you'll need to make two divs. The first one is for the sidebar itself; the second one is for your post content. This is because the sidebar's JS code is going to search for titles in the post content's div; then it'll generate links for those paragraphs and add them to the sidebar's div. Remember to give IDs to the headers (if your CMS/SSG isn't doing it already)!

<main>
    <aside>
        <div id="post__sidebar-left">
            <h4>Paragraphs</h4>
            <!-- Leave this empty; the script will autofill it -->
        </div>
    </aside>
    
    
    <div class="post__content">
        <!-- Add your post here. The following lines are just examples -->
      <h2 id="hello">Hello</h2>
      Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eu dui sit amet diam mollis facilisis sed sed lectus. Mauris vel risus maximus, molestie eros eu, lacinia massa. Ut quis ornare risus. Praesent vestibulum commodo dolor eu lacinia.
      <h3 id="subtitle-1">Subtitle 1</h3>
      Sed faucibus, purus quis laoreet commodo, ante tellus auctor felis, faucibus tincidunt sapien nisi eu leo.
      <h3 id="subtitle-2">Subtitle 2</h3>
      Sed faucibus, purus quis laoreet commodo, ante tellus auctor felis, faucibus tincidunt sapien nisi eu leo.
      <h2 id="another-title">Another title</h2>
      Sed vulputate turpis massa, eget hendrerit nunc ullamcorper sed. Phasellus porttitor aliquet faucibus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque gravida diam id erat interdum, eu bibendum massa interdum. Maecenas cursus nulla quis enim mollis accumsan. Aenean id blandit libero.
    </div>
</main>

That's pretty much it for the HTML part. Again, pretty easy!

Making the sidebar with CSS

We wouldn't have called this a sidebar if we didn't intend to make it stick to a side. This part really depends on how your pages are structured, but for this example I'll do it in an extremely simple way: flexbox. Note that this is just so that I can give you a working example, but your configuration might vary wildly and you might prefer to do this in some other way. Anyway, here's the code:

main {
  display: flex;
}

Another thing you might want to do is give your currently viewed paragraph a different style - for example, by making it bold, or by coloring it a different way. You can do it, for example, like this:

#post__sidebar-left a.current {
  color: red;
}

We are going to apply the current class via JS later on.

Also, since this is a sidebar, you probably want it to be sticky. Here's a way to do it:

#post__sidebar-left {
  position: sticky;
  top: 0;
}

Yep, that's it in this case. Tada!

Connecting everything with magic: writing the JS script

This is the hardest part, but fear not: I'll explain the different bits as we go on.

Initializing needed variables

First of all, we're gonna need two arrays to store the paragraphs' headers and their respective links:

let headers;
let sidebarLinks;

Generating the links

Then, when the whole page has loaded, we want to check for every header in the post content's div, and store it in the array we just created:

$(document).ready(function () {
    
    headers = $(".post__content h2, .post__content h3").toArray();
    
    const sidebar = $("#post__sidebar-left");

    for (let i = 0; i < headers.length; i++) {
        const currentHeader = headers[i];
        const headerText = $(currentHeader).text();
        const headerId = $(currentHeader).attr("id");
        const headerType = $(currentHeader).prop("nodeName").toLowerCase();

        const newLine = "<" + headerType + "> <a href=\"#" + headerId + "\">" + headerText + "</a> </" + headerType + ">";
        sidebar.append(newLine);
    }

    sidebarLinks = $("#post__sidebar-left a").toArray();
    
    <...>
});

Let me explain this line by line.

$(document).ready(function () {
    <...>
}

This means that we want to wait for the whole document (page) to be loaded before running the script. Also, we only want to run it once (again, when the document has loaded) because the content isn't going to suddenly change, and thus we don't need to check multiple times.

headers = $(".post__content h2, .post__content h3").toArray();

This stores every <h2> and <h3> tag found in the post__content div into the headers array we just created.

const sidebar = $("#post__sidebar-left");

This is because we need a way to edit the sidebar's content (by adding the paragraphs' links to it). So, we are simply picking the sidebar's div by its unique id (post__sidebar-left).

for (let i = 0; i < headers.length; i++) {
    <...>
}

Now, we want to loop through the headers array, so that we can process every header, one at a time.

const currentHeader = headers[i];

This is to load the current header we are referring to, inside of the loop.

const headerText = $(currentHeader).text();
const headerId = $(currentHeader).attr("id");
const headerType = $(currentHeader).prop("nodeName").toLowerCase();

This is to load the different properties of the said header: its text ("Title Number One"); its ID ("title-number-one") and its type (h2, h3, ...).

const newLine = "<" + headerType + "> <a href=\"#" + headerId + "\">" + headerText + "</a> </" + headerType + ">";

We have to store all this data because we are gonna use it to generate the link in the sidebar. The newLine is a simple HTML string we are generating at the moment. This string is what we'll be adding to the sidebar's div. For example:

<h2> <a href="header-link"> Header Name </a> </h2>

Now, we want to add this string we just generated to the sidebar:

sidebar.append(newLine);

Voilà! That's it to generate a dynamic sidebar. However, we also want to highlight the currently viewed paragraph.

Highlighting the current paragraph

To do so, we need to run another, last, instruction in the $(document).ready(function(){ } method:

sidebarLinks = $("#mind-post_sidebar-left a").toArray();

This is so that every link we just generated in the loop will get stored in the sidebarLinks array we defined at the beginning. Then, we need a new method that checks our reading position whenever we scroll:

$(document).ready(function () {
    <...>
        
    $(window).scroll(function () {
        let bottomScroll = $(window).scrollTop() + ($(window).height() / 2);
        let found = false;

        for (let i = headers.length - 1; i >= 0; i--) {
            const currentHeader = headers[i];
            const currentSidebarLink = sidebarLinks[i];
            $(currentSidebarLink).removeClass("current");

            const headerVPPosition = $(currentHeader).offset().top;

            if (!found && bottomScroll > headerVPPosition) {
                $(currentSidebarLink).addClass("current");
                found = true;
            }
        }
    });
});

Again, let me explain how and why this works.

$(window).scroll(function () {
    <...>
}

This method, that goes inside of the other one ($(document).ready(function () { }), is called every time we scroll the page. We need this because, obviously, you'll be scrolling the page as you read, and eventually you'll switch to a new paragraph.

let bottomScroll = $(window).scrollTop() + ($(window).height() / 2);

This is to know how may pixels you have scrolled so far. I'm dividing the window height by 2 because this way we'll be looking at the middle of the window instead of the top (I believe most people keep the text they're reading near the middle of the screen, rather than the upmost side).

let found = false;

This is a simple boolean that allows us to know if we have found the div we're looking for, so that we can stop. This will be clearer as you go on.

for (let i = headers.length - 1; i >= 0; i--) {
    <...>
}

Again, we are looping through all headers - however, we are doing this from the bottom side rather than from the beginning. This is because we want to stop at the lowest one you're looking at.

const currentHeader = headers[i];
const currentSidebarLink = sidebarLinks[i];

These are two variables we need: the current header we are analyzing in the loop, and its link.

$(currentSidebarLink).removeClass("current");

This is to remove the current class - we only want the currently viewed paragraph title to have it. We'll remove it from everything and eventually reapply it to the correct div. This is not an issue because if a div is already without that class, it will simply do nothing.

const headerVPPosition = $(currentHeader).offset().top;

This is to know the header's position in pixels from the top, so that we can check if we are effectively looking at it (by comparing it to our current scrolling position).

if (!found && bottomScroll > headerVPPosition) {
    $(currentSidebarLink).addClass("current");
    found = true;
}

This is the final step! We are checking if we had already found a paragraph we are looking at. If we haven't, then we need to check if the current one is actually the correct one. To check if, we are comparing the pixel coordinates of our screen (bottomScroll) and the current paragraph (headerVPPosition).

If this is the correct one, then set found to true and add the current class to the header.

Implementing the script

Now, the last thing you need to do is to save the script we just created, and include it in your HTML file, like this (let's suppose you saved the script in the /scripts/ folder under the name of sidebar.js):

<script src="/scripts/sidebar.js"></script>

Conclusion

Working Example

Finally, we are done! I hope this wasn't too painful, and that I was clear and exhaustive enough to make you understand everything. Now, to reward you for the super good job you did, here's a working CodePen that you can copy-paste wherever you want!

See the Pen zYKWZvQ by Lorenzo Dellacà (@mind-overflow) on CodePen.

TL; DR - I don't care about your cool story, just give me the commands: click here.

I've recently began using Ubuntu 20 as my daily driver, and as I started migrating everything from my Windows installation, I finally got to the audio and video department. Since we all have to attend online meetings these days, I have worked on my setup too, which consists on two main things: DroidCam, to make my phone into a webcam, and NoiseTorch, to remove anything that is not my voice from my audio stream.

Everything worked smoothly for a few days, until I installed a kernel update. This morning I had to attend an online lesson - and whoops! DroidCam was no longer working. I was getting the error Device not found (/dev/video[0-9]). Apparently, the v4l2loopback-dc module got removed somehow. Anyway, I started tinkering again, I installed the droidcam-dkms package but it failed, I tried uninstalling it but it removed everything... It was a mess. I finally got it to work - however, the video stream was freezing every few seconds, and the audio in my headphones was popping and crackling like crazy. Also, NoiseTorch was listing every one of my inputs as (incompatible?) - they were working fine a few minutes earlier.

My last chance was to try and fix PulseAudio. I knew something was messed up, but I really couldn't figure out what. My configuration file wasn't changed, nor was the system one. Disabling timer-based audio scheduling (tsched=0) helped a little, but it didn't fix the issue. I really didn't know what to do.

I had the idea of trying to completely purge and reinstall the pulseaudio and alsa* packages. However, if you try:

apt autoremove --purge pulseaudio

You will be greeted with an awesome list of dependency packages that will be removed too, and those will include ubuntu-desktop, ubuntu-desktop-minimal and other completely unrelated system stuff. That's obviously something you do not want to uninstall.

I was lucky, however. I had a brilliant idea: I could bypass apt entirely and use dpkg. It felt like magic, when everything suddenly started to work.

The very simple process

As long as your audio configuration and settings were working when you installed Ubuntu, and the malfunctioning state is caused by your misconfiguration and/or fault, restoring the audio driver to default state might actually be helpful.

First of all, completely purge and remove your pulseaudio and alsa packages by running:

sudo dpkg --purge --force-depends pulseaudio alsa-base alsa-utils

Don't worry about dependency warnings - we are aware of that; that's the purpose of bypassing apt. We want to only uninstall those specific packages, and since we are reinstalling them in a few seconds, there's no need to worry about missing dependencies.

Then, run the following command:

sudo apt install pulseaudio alsa-base alsa-utils

Voilà. Reboot your machine and your audio will be good to go, ready to play your favorite tunes, meme videos and whatnot.

Since you are here, you probably know what I'm talking about. Ubuntu 20.04 Focal Fossa (and 20.10 Groovy Gorilla) has a pretty unusual bug, if you have the experimental "fractional scaling" feature enabled: when you log-in with your password, your mouse cursor gets stuck at its current position, while a new, bigger one appears and tracks your mouse movements. The bug is caused by this issue, described on the Ubuntu mutter issue tracker. However, since an official fix is not currently available, I've found a workaround that pretty much fixes it every reboot, and made it into a program:

mind-overflow/gnome-fs-duplicate-cursor-fix

Fix Ubuntu/GNOME’s “duplicate cursor” fractional scaling bug. - mind-overflow/gnome-fs-duplicate-cursor-fix

GitHubmind-overflow

Installation

The installation process is pretty easy, although admittedly not one of the shortest.

Step 1 - Fractional Scaling

Make sure that fractional scaling is enabled, by going in your System Settings ➙ Monitors ➙ Fractional Scaling. If it's disabled, turn it on and configure your monitors.

Step 2 - Installing Java

Open up a new Terminal window and type java -version. If your output looks similar to this, you are good to go:

openjdk version "1.8.0_272"
OpenJDK Runtime Environment (build 1.8.0_272-8u272-b10-0ubuntu1~20.10-b10)
OpenJDK 64-Bit Server VM (build 25.272-b10, mixed mode)

If, instead, you get java: command not found, just run sudo apt install -y default-jre and finally re-check the correct installation with the previous command.

Step 3 - Adding the fix

While still in the Terminal, download the latest version of the fix from the official GitHub repo linked above, with the following command:

wget -O ~/ScreenScalingFixer.jar https://github.com/mind-overflow/gnome-fs-duplicate-cursor-fix/releases/download/v1.0/ScreenScalingFixer-1.0-SNAPSHOT.jar

Then, create a new directory for the program and move it inside:

mkdir ~/screen-scaling-fixer/

mv ~/ScreenScalingFixer.jar ~/screen-scaling-fixer/ScreenScalingFixer.jar

The next step is to create a startup script, which will run every time after you login. Run the commands:

echo "sh -c \"cd ~/screen-scaling-fixer/ && java -jar ~/screen-scaling-fixer/ScreenScalingFixer.jar\"" > ~/screen-scaling-fixer/start.sh

chmod +x ~/screen-scaling-fixer/start.sh

Finally, enable the recently created script by executing the following lines in the Terminal:

mkdir ~/.config

mkdir ~/.config/autostart

printf \
"[Desktop Entry]\n\
Name=fs-fixer\n\
GenericName=fs-fixer\n\
Comment=fix gnome scaling duplicate cursor\n\
Exec=sh -c ~/screen-scaling-fixer/start.sh\n\
Terminal=false\n\
Type=Application\n\
X-GNOME-Autostart-enabled=true\n\
X-GNOME-Autostart-Delay=1\n" > ~/.config/autostart/fractional-scaling-fix.desktop

chmod +x ~/.config/autostart/fractional-scaling-fix.desktop

Step 4 - Final configuration

At this point, you have correctly installed and enabled the fix. Now, the last thing you need to do is configure it!

Move into the correct directory and launch it:

cd ~/screen-scaling-fixer && ./start.sh

It will generate the configuration file and quit instantly. Now, type xrandr. You should get a list containing all of your monitors. What you need to do is find the correct port your fractional-scaling-enabled monitor is plugged into. It should be something like DisplayPort-1, HDMI-A-0 or eDP-1... Write that down somewhere. Don't worry if you have multiple scaled monitors, one is enough.

Now, edit the config.yml file in the ~/screen-scaling-fixer directory. In my case, I'm going to use the text editor nano:

nano ~/screen-scaling-fixer/config.yml

The file will look like this:

enable: false
delay: 2000
monitor-connector: 'DisplayPort-1'
scale: 1.5

Change enable: false to enable: true, or the script won't run.

Then, change monitor-connector: 'DisplayPort-1' to the one you just found with xrandr, such as monitor-connector: 'HDMI-A-1'.

Now you need to set the scale. This is the effective scale you want your monitor to be at, and this must be the same you used in the system settings. So, 150% becomes 1.5; 125% is 1.25, etc.

Finally, set the delay, in milliseconds. The delay is how long the script needs to wait before actually running. Set it to something that you think is enough for your computer to fully complete the login sequence. If you are running from an SSD with a decent processor, 2000 will be enough. If the delay is too short, you will simply see no effect. If this is the case, try opening the config.yml file again and increasing the delay. Then, close nano by pressing CTRL+X and then Y to save the file.

Step 5 - Check that everything works

You are finally done! I really hope this didn't take too long. Now, to test that everything works correctly, run the program again from Terminal:

cd ~/screen-scaling-fixer && ./start.sh

Your screen should flash twice for a few seconds, and when it ends flashing, your monitor configuration should be the very same one you had before running it. Congratulations! Now, you just need to logout and log back in, to see it work its magic and make the dead cursor disappear.

Conclusion

Until the development teams of Ubuntu, GNOME and mutter have a fix ready for this, I think this is the best solution to the problem. It certainly isn't the prettiest, but it works, and it does it well enough, at least for me. I think waiting 2 seconds after logging in is not a big deal, especially since this solves the problem of having an ugly cursor always stuck on the screen.

If you were unable to follow some steps or have any problem/question about this, please leave a comment below and I'll try to help you as soon as possible!