Scinonova logo

Okategoriserad

IoT interview P.4 – Matz Larsson

by

At Scionova, we strive to make the world a little bit better. But what does that mean in practice? To give you an insight into our daily work, we have performed an interview series asking our consultants about their experiences within IoT.

What does software developer Matz Larsson work with in his current assignment? Continue your read and find out!

–

Matz, tell us about your current role and what tasks you work with? 

The project I currently work in is a sort of flight recorder. We make an application for a vehicle company where the user has a configuration tool and can choose which specific signals from the car they want to listen to. The information gets pre-processed and can then be transferred to the hardware, which is the very core of the flight recorder. The hardware then gets plugged into the car and the measuring can start. 

When the tester is satisfied with the number of signals and information, the configuration tool is connected to the hardware. It can then download the collected data in order to inspect the value of the signals.  

Doing this, the testers can verify that ECUs are functioning as expected according to the different cases that are being investigated. If the results show that they don’t, the recorded data can be used in troubleshooting to investigate it further.   

My role is a classic developer role. I mainly work with the configuration tool, but I tend to also do a little work wherever it’s needed. Since, if you’re making some changes in the tool, you also have to make corresponding changes on the hardware side.  

 

What language and platform do you work in? 

I mainly work in Windows, with a mix of C++, C and a little bit of C#. And on the hardware side, we work in Linux.
 

What value, would you say, is created through your work and for whom? 

Our client is, as mentioned before, a vehicle company. What we do and create is used in order to verify the cars and examine their behavior, and is not found in the car that end customer drives. So, from our client’s perspective, the value is the fact that they get an easy and smart way of measuring.

There’s another similar product called CANalyzer, which can be used to make the same measurements. It’s big on the market, and has a lot of features, but it demands even more resources. Having the tool that we create, makes working more cost efficient and just easier. It also allows us to make features that are based on our client’s specific needs. And we can tweak them just as we please, unlike CANalyzer. 

But the main value has to be that the tool enables a way to verify that the car actually works as expected.   

 

Is there an overall problem that engineers try to solve within this field? If so, what is that? 

One of the things that we try to do, is to make it easier for our client’s testers. That means that everything has to be measured correctly, down to every little detail. Not only in terms of signal values but also in terms of timing and timeouts.  

If not, the outcome may be that the testers thinks that there’s something wrong with a product even though it’s not, and starts troubleshooting it in vain. Just because they’ve received an incorrect value from our measurement tool. 

Hence, the accuracy of the process is crucial and has to be on a high level. It’s also a big selling point for the project that I’m in, that we historically have had, and still have, a very stable product. It’s a little bit like with self-driving cars; the basic premise is that it should never go wrong.  

That’s why it’s so important that we ensure that combinations of different features work together. And that new features don’t affect the current product in a negative way.  And the larger the product gets, with all its features, the more complex it becomes. 

 

Can you see any trends in the nearby time, regarding the development of this? 

Generally, if you look at the current situation, the industry is about to change direction but not a whole lot. Traditionally, CAN-busses have been used to communicate between different ECUs but are gradually shifting over to Ethernet. Because of the fact that Ethernet can handle a higher speed. But this won’t change my tasks remarkably, it will just be a new medium to transfer the data through.  

However, what I think will change, is not only the fact that more data will be sent at a faster speed. I believe Ethernet will unlock new possibilities regarding how to use data and communication channels. Which will definitely affect my, and our, way of working.  

–

Want to continue your read further? Explore our blog!

Want to know more about the work of our consultants? Stay tuned for coming posts in the interview series! Follow us on social media to get notified.

 

IoT interview series P.2 – Joakim Ceder

by

At Scionova, we strive to make the world a little bit better. But what does that mean in practice? To give you an insight into our daily work, we have performed an interview series asking our consultants about their experiences within IoT. 

Find out below what Joakim Ceder, senior consultant and co-founder of Scionova, has to say about his current role and assignment:

–

Joakim, tell us about your current role and what tasks you work with.

– My role is called “Requirement Specialist”. I work with a customer who produces smart home devices and my task is to help them ensure that their products follow prevailing requirements in each market they want to work in. This means that I work towards authorized certification companies and authorities around the whole world. 

.

What value is created to the customer or end user through your work?

– For the customer, the main value is that their products are legal so that they can in fact be sold. And that this process, of certifying products, is as efficient as possible.  

The higher value is that the products are safe for the end user, so that they’re not hazardous in any way or disturb other devices. My work also ensures that the end user’s expectations of the products are being met, which is important in protecting the brand.

 

What is the overall problem within smart home products that engineers and developers try to solve?

– The overall problem that companies try to solve with smart home products, is to make people’s lives easier. But in order to do so, the products have to tick off the safety and security boxes! With privacy being a big part of it. So I would say that’s the fundamental problem that engineers and developers work with. 

I believe that, in the future, we are going to work a lot with intelligent actuation of our smart home devices. Instead of controlling our devices manually, they will start automatically when we need them to. Improving the intelligence of our smart home products will also enable them to let us know when they need to be maintained, before they might break. That will cause people less problems in their homes, and yet again make their lives easier.

 

How does this development benefit companies?

– For the companies that sell smart devices, data can help them develop their existing and future products. By analyzing data from sold products, they can learn about how they are being used. In that way, they can choose to develop the most used features, and remove others. With data it’s also possible for companies to predict when the products will break. With this information, they will be able to enhance the quality of their products where it’s needed.

 

Why is it important to optimize products in this way? 

– It’s mainly about making the end user as satisfied as possible. In a bigger perspective, if we are able to make sure that products last longer, by fixing them before they break, the impact on the environment will be less. Same thing with the possibility to update their software, the products will stay modern for a longer amount of time.

–

Have you missed part 1 of this series? Click here to get to it! 

Want to know more about the work of our consultants? Stay tuned for coming posts in the interview series! Follow us on social media to get notified.

IoT interview series P.1 – Peter Fredriksson

by

At Scionova, we strive to make the world a little bit better. But what does that mean in practice? To give you an insight into our daily work, we have performed an interview series asking our consultants about their experiences within IoT. First out is Peter Fredriksson, senior consultant and co-founder of Scionova. Here is what he has to say:

–

First off, what is your current role and what tasks do you work with?

– The latest assignment I worked on was a system to make trucks smarter. Trucks that are used in big warehouses, both self-driving ones and those with drivers. The task was to create a more efficient inventory management and to better keep track of when a truck needs maintenance.

What I did was to manage the connection between the trucks and the Wi-Fi or 3G/4G/LTE network. Simply, to give the trucks access to the internet.

 

What platform and language did you work in?  

– We used a fairly standard Linux distribution for embedded systems and developed in C for the most the part. For some parts we did use Python.

 

What value was created to the customer or end user?

– The biggest value was created for the customer’s customer. Apart from making the work in the warehouse more efficient, the absolutely most important value was improved safety. One of the most dangerous situations in a warehouse is when two trucks go around a corner, both typically in a hurry. By using positioning and radar systems we could prevent these types of collisions to occur. In that way we saved lives or serious injury.

 

What is the overall problem that developers try to solve?  

– What is closest to my heart, is safety and improving it in different ways. It is also about making processes more efficient in order to save time and resources. I think making systems smarter will play a big role in meeting and mitigating the effects of the environmental and climate challenges we are facing. 

 

In what way do you think that connectivity can help lessen our impact on the environment?

– In the way that you can ensure to only use the amount of resources that is really needed, for example when we are talking about manufacturing and so on. Also in making each step in the process as efficient as possible. With more data you can definitely make better and smarter decisions.

It would be fun to work with projects like this in the future, where the main goal is to save resources.

 

Want to know more about the work of our consultants? Stay tuned for coming posts in the interview series!

Adding ITS-JIRA to Gerrit [WALKTHROUGH]

by

its-jira is a Gerrit plugin to automatically interact with Jira when actions are taken in Gerrit. It is one of many plugins in a family that essentially does the same but for different issue ticket systems (ITS). There are similar plugins for Bugzilla, Github, IBM RTC, Storyboard etc. Basic actions include:

  • Commenting on tickets/stories when new patchsets have been uploaded
  • Moving tickets/stories to particular states when patchsets get reviewed/approved/merged etc.

This post will guide you on how to set up its-jira and make it play nicely with both Gerrit and Jira.

Pitfalls (of doom) and handy advice

During working with setting up its-jira for the internal Scionova project ScIoT I found many pitfalls in which you could fall rather deep and spend an enormous time trying to solve issues that could have easily been solved in another way. This section tries to document these pitfalls and give some handy advice on things that will speed up your process.

Administrative rights

Make sure to get administrative rights to Gerrit before starting to work with this, it helps a lot. This may sound basic, but it is actually much more important than you might think. As an example; I tried to do a manual install of its-jira via the Gerrit SSH daemon for a long while until we got administrative rights and realized the Gerrit dev team actually had implemented a plugin handler in the WEB UI which was way much easier. It just wasn’t visible for non-administrators (for obvious reasons). So make sure you have permissions until you start poking around.

The docker daemon needs to run with elevated privileges on your host machine to carry out some of its features and hence we need to access it with elevated privileges as well. There are two approaches here, either issue commands for docker as root or create a group called docker in which your user is part of. I prefer the first solution if possible just due to its simplicity and will extensively use sudo with docker in this post. However, if you feel like using the docker group solution there is some more info on the topic here. Either way, make sure you have permission to poke around before you start.

Persistent storage in docker

Docker is a great technology, but sometimes you can forget to make your data persistent and all work goes poof. Make sure that all files you alter are persistent before modifying them. See more info in the upcoming sections.

Editing files in docker

Docker containers are generally not made to poke around in and hence they rarely include editors by default. You could of course install an editor inside the docker container or mount directories whenever you want to edit something but that sometimes feels like overkill. Instead, I use a home-written script to download the file from the docker container, open an editor and then sync it back again. That way I can reuse it for all docker containers without the need to mount/unmount or install things. The (bash) script goes as follows:

#!/bin/bash

container=$1                      # Container name or ID
path=$2                           # Path to file in docker
uid=${3:-1000}                    # Default UID 1000
gid=${4:-1000}                    # Default GID 1000

tmpfile=$(tempfile)               # Get temp file name

# Print information (debug reasons, optional)
echo "Editing docker file:"
echo "  Container : $1"
echo "  File      : $2"
echo "  Owner     : $3:$4"
echo "  Using tempfile $tmpfile"

docker cp $1:$2 $tmpfile          # Fetch file from docker
chown $3:$4 $tmpfile              # Set correct user rights
nano $tmpfile                     # Edit file (I use nano editor)
docker cp $tmpfile $1:$2          # Copy file back to docker
rm $tmpfile                       # Clean up temp file

One handy thing with this is that you can now easily create an alias function to provide some of the common parameters (e.g. container name). In my case I added the following to my .bash_aliases:

function editgerritfile(){
    sudo ~/edit_docker.sh dockergerrit_scio_gerrit_1 /var/gerrit/$1 1000 1000
}

This makes it very simple to work with files in docker. To edit the main gerrit config I just need to run

editgerritfile etc/gerrit.config

Installation of its-jira

This guide will assume you are doing the install for Gerrit in a docker container. If this is not the case, just skip the first section about docker.

Prepping docker

This section assumes your docker installation is similar to the official one with docker-compose. This guide makes sure to keep the folders etc, git and db persistent but does not do the same with the plugins folder. The process for fixing this is threefold.

1. Copy all default plugins to your persistent storage folder

Gerrit comes preinstalled with a bunch of rather essential plugins. Before making any changes to our docker-compose file we need to sync those plugin *.jar files to our machine. Do this by running the following command on the host machine (while your docker container is up and running):

sudo docker cp docker-name:/var/gerrit/plugins /your-persistent-storage/plugins

In the case of ScIoT we had our persistent storage in the /external/gerrit/ folder, so we got:

sudo docker cp dockergerrit_scio_gerrit_1:/var/gerrit/plugins /external/gerrit/plugins

2. Make sure permissions are correct

Nice, now we have the files on the host machine. But what about permissions? Docker will not preserve file ownership when copying between container and host machine, instead files are created with root as the owner on the host machine. This is rather problematic due to the fact that the persistent storage functionality tries to preserve ownership rights and will hence use the root user when we sync it back. If we set up persistent storage now and restart our docker container now the gerrit process will get an access denied if it tries to access the plugins folder. So how do we solve this? Inside the docker container the gerrit user owns the plugins folder. In our docker container the gerrit user had UID 1000 and GID 1000 (see Linux UIDs if you are uncertain on UIDs) and hence we want to set the owner of our plugins folder and all of its files on the host machine to the same. In our case this yielded the command

sudo chown -R 1000:1000 /external/gerrit/plugins

Note that the host machine not necessarily needs to have any user that matches the UID/GID combination.

3. Update you docker-compose config

Now we only have to update the docker-compose file to make sure plugin files are persistent. Update the volumes section with the line marked with an arrow. If you used another directory than /external/gerrit/ for persistent storage, make sure to use your path instead.

....

    volumes:
      - /external/gerrit/etc:/var/gerrit/etc
      - /external/gerrit/git:/var/gerrit/git
      - /external/gerrit/db:/var/gerrit/db
      - /external/gerrit/index:/var/gerrit/index
      - /external/gerrit/cache:/var/gerrit/cache
      - /external/gerrit/plugins:/var/gerrit/plugins       <-----------
      
....

4. Restart your docker container

Restart your docker container. Everything should start up and get running as before, with the only exception that plugins are now being synced persistently. Make sure you do not get any errors here before proceeding the tutorial.

Security concerns

Before moving on I would like to just say a few words about security here. In Linux you can set read/write/execute rights on a file to a user ID for a user that does not exist. This is very useful, especially in cases like this where the owner ID of a file is the same across two systems. However, this also opens up for security issues.

First off, assume the user ID used in the docker container does not exist on the host system. We still set the file rights and everything works, right? The problem here is that if an attacker can create an account with that specific user ID, he/she has full access to plant new (potentially malicious) plugins in our plugins folder.

Let us also assume the other case; the user ID user in the docker container does exist on the host system. If the attacker can gain access to this account somehow, we end up in the same scenario as in the last paragraph. Hence the importance of strong passwords and firm security measurements/routines for that specific account automatically increases.

Unfortunately docker-compose has, as far as I am aware, no easy way to specify the access rights of the mounted folder, but there exists workarounds. The best solution I have seen is to write a custom script that runs chown inside the docker container itself and lets you keep root as the owner to the plugins folder on the host machine.

Remember to always think of security when doing these small hacks and weigh the ease of the solution against risks of potential attacks. But let us get on with the its-jira installation.

Prepping Jira user

Before we start to configure Gerrit we should take a look at the Jira side and set up some authentication parts for its-jira. Follow these steps:

  1. Choose what Jira user to use (do either a or b)
    1. Create a new user (recommended)
    2. Reuse an existing one (remember that Jira Cloud free only have 10 user slots)
  2. Log in as the user from step 1
  3. Generate API token
    1. Go to Atlassian API Token generator page
    2. Press Create API Token
    3. Give the token a name, e.g. its-jira
    4. Copy the token and make sure to keep it. We will use it soon!

Update Gerrit configs

This section will assume your Gerrit installation is located at /var/gerrit/. If it doesn’t, make sure to keep that in mind. Furthermore, some parts also tell you to edit files. If you are running Gerrit in a docker container and are not used to edit files in docker (which usually comes without any editor installed), please see the previous section Editing files in docker if you skipped it.

Add authentication

First off, we need to add user settings to access Jira. Use the email you usually enter when logging into Jira and use the token generated in the previous section as value for password (see code below).

Edit /var/gerrit/etc/secure.config and add the following lines:

[its-jira]
        url = https://your-subdomain.atlassian.net/
        username = your-email
        password = your-jira-api-token             # (generated in previous section)

Add basic config params

We need to configure how its-jira should match for ticket names and access their update pages. Ticket names are assumed to be included in your commit messages in order for its-jira to function properly. Make sure to update below markup with your subdomain and preferred association level before adding it to the configuration file.

Edit /var/gerrit/etc/gerrit.config and add the following lines:

[commentLink "its-jira"]
        match = ([A-Z]+-[1-9][0-9]*)
        html = "<a href=\"https://your-subdomain.atlassian.net/browse/$1\">$1</a>"
        association = SUGGESTED

Available values for the association entry are:

  • MANDATORY :  blocks commits without an included ticket name
  • SUGGESTED :    shows a warning for commits without an included ticket name
  • OPTIONAL :        does not interact with tickets without an included ticket name

Configure actions

its-jira needs to know what you want it to do when something happens. This is where actions come into place. Your actions configuration file should be put in the directory /var/gerrit/etc/its/ (create if it does not already exist) and be called either actions.config or actions-its-jira.config. Settings in actions.config will be shared among all ITS-plugins whilst actions-its-jira.config will be exclusive to Jira. If you do not plan to add integrations to multiple issue tracking systems, I would recommend using actions.config out of simplicity.

The syntax for actions markup is well documented by the parent plugin its-base here. I would recommend reading that page before constructing your actions configuration, it is very efficiently structured and gives you a good overview of what is possible with the its plugin family.

As an example of an action config I post our current configuration here (WIP). As you can see we both comment on issues and move them to different states depending on the received Gerrit event.

[rule "open"]
    event-type = patchset-created
    action = add-standard-comment
    action = In Progress
[rule "resolve"]
    event-type = comment-added
    approvalCodeReview = 2
    action = add-comment An approval was given for this issue
    action = In Review
[rule "merged"]
    event-type = change-merged
    action = add-standard-comment
    action = Done
[rule "abandoned"]
    event-type = change-abandoned
    action = add-standard-comment
    action = To Do

[rule "fixneeded"]
    event-type = comment-added
    approvalCodeReview = -2,-1
    action = add-comment A negative code review was received
[rule "positivereview"]
    event-type = comment-added
    approvalCodeReview = 1
    action = add-comment A +1 code review was added. Keep up the good work!

[rule "verifiedsuccess"]
    event-type = comment-added
    approvalVerified = 1
    action = add-comment Latest patchset was Verified +1
[rule "verifiedfail"]
    event-type = comment-added
    approvalVerified = -1
    action = add-comment Latest patchset failed the verification

NOTE: add-standard-comment can be an efficient way to check that something works at all. However, this action is only defined for patchset-created, change-merged, change-abandoned, and change-restored.

Enable its-jira to run

If you haven’t worked with repositories on this Gerrit server before, I would recommend to setup an SSH key with your account before proceeding. Generate an SSH key on your local machine and enter the public key on the following page http://YOUR-GERRIT-SERVER/settings/#SSHKeys. Replace YOUR-GERRIT-SERVER with the IP/domain of your Gerrit server. Your SSH username can be found at the top of your profile settings page on Gerrit. Now you should be able to push/pull/fetch etc. using SSH! (read on for more info)

Enabling its-jira requires doing changes to the project configuration file in the chosen project repository. We have two options:

  1. Enable it for all projects (apply changes to All-Projects repository)
  2. Enable it for a specific project (apply changes to the repository of that project)

First off, pull your selected repository and checkout the branch refs/meta/config. If something fails in this step, make sure you actually have permission to do this (requires Administrator or Project Owner in the default settings).

git clone "ssh://username@YOUR-GERRIT-SERVER:29418/PROJECT-NAME"
cd PROJECT-NAME
git checkout refs/meta/config

Now you should see a file called project.config in your repository base directory. Edit it and add the following lines

[plugin "its-jira"]
enabled = true

If you want to limit its-jira to specific branches only you can do this as well. Multiple branches can be specified with either explicit names or regex expressions. This is a basic example of how it might look if you want to run it on the master branch and all branches whose name starts with stable-.

[plugin "its-jira"]
    enabled = true
    branch = refs/heads/master
    branch = ^refs/heads/stable-.*

Once you are done with editing, it is time to commit your changes. If you feel like you really need someone to review the changes, do a normal push. If you feel like this is not necessary, and it is not too much activity on the branch yet, force pushing may be a good option. I spent a good long while trying to get around that we required the Verified flag on all pushes, but no automatic verification process was run on the /refs/meta/config branch (due to reasonable reasons). Either way, make sure your work ends up pushed.

Install plugin

Phew, now the configuration should be done. Make sure you completed all steps before doing the installation, or the install will simply fail (and you will have to start troubleshooting).

Gerrit has a nice simple UI for installing and updating plugins. Note that this retrieves the latest version of the plugin, which may not be what you want if you run an older version of Gerrit. I would recommend to use the Gerrit UI firsthand and then fall back to a manual install if you get errors on git pushes or adding reviews.

Install from Gerrit UI (latest version)

Log in as an administrator account and then navigate to Plugins > Manage from the top menu. On this page, scroll down to its-base and install it. This is a dependency for its-jira so make sure you install it in the correct order. Once its-base is installed, press install for its-jira. If you have succeeded in updating the configurations this should be without errors as well.

Manual install

Open a terminal into your docker installation of Gerrit

sudo docker exec -it CONTAINER-NAME /bin/bash

Move into the /var/gerrit/plugins/ folder and download the correct version of its-jira.jar and its-base.jar matching your Gerrit version from here. For example, we were running Gerrit version 3.1.2 and hence I downloaded the artifacts from plugin-its-base-bazel-stable-3.1 and plugin-its-jira-bazel-stable-3.1. The commands for this version would be as follows

cd /var/gerrit/plugins
wget https://gerrit-ci.gerritforge.com/job/plugin-its-base-bazel-stable-3.1/lastSuccessfulBuild/artifact/bazel-bin/plugins/its-base/its-base.jar
wget https://gerrit-ci.gerritforge.com/job/plugin-its-jira-bazel-stable-3.1/lastSuccessfulBuild/artifact/bazel-bin/plugins/its-jira/its-jira.jar

Now either restart your docker container or restart Gerrit inside of the docker container to reload the plugins. Make sure to check startup logs to see that the its plugins load correctly. The correct output from its-jira (at least for stable version 3.1) looks like this:

....
INFO  com.googlesource.gerrit.plugins.its.jira.JiraModule : JIRA is configured as ITS
INFO  com.googlesource.gerrit.plugins.its.jira.JiraItsStartupHealthcheck : Connection to Jira (https://yourdomain.atlassian.net/) succeeded: {"status"="ok","system"="Jira","version"="1001.0.0-SNAPSHOT","ur ...
INFO  com.google.gerrit.server.plugins.PluginLoader : Loaded plugin its-jira, version e67eeeea39
....

Test it out!

Now is time to test your installation. Create a ticket/story and an accompanying branch and make sure everything works as you expect it too. Add patchsets and reviews to see that its-jira can react to the changes. If it doesn’t work as it should, go check out your gerrit logs. The logs are often rather verbose on what went wrong and helped me more times than I dare to admit.

Does it work now? Nice! ?

Helpful resources

ITS-JIRA official documentation

ITS-BASE configuration documentation

Making Gerrit play nice with Jira (2018)

 

Matz Larsson

Matz Larsson, Software Developer

Taking the step from studies to work life

by

This blog post will be divided into two separate entities. First I will tell you about my journey from studies to work life and bring up some thoughts on that process. This part only considers my personal experience and might contradict other views, but in my experience, it is not too far from what I have heard from associates about their own journey. Secondly, I will have a look back at my years at Chalmers University and compare studies and work life to figure out the important question – which one rocks the most?

 

Part 1: The journey from studies to work life

 

Background

When I was younger I rarely thought about my future. Questions like “What do you wanna become when you grow up?” of course ran through my head once or twice but mostly I just did what I thought was interesting at the moment. It has always been quite easy for me to learn new stuff and adapt to situations rather quickly which meant that my attitude to prepare for the future was quite close to “Pffft, I guess I’ll solve it along the way”.

Getting closer to the end of the studies

However, during the last years at the university, this mentality changed. Suddenly it felt important to do everything right – select the correct master’s programme, select all my courses with care and generally make sure all choices aligned in a clear direction for the life that was to come after my studies were done. As a consequence of this, I also started worrying about the future and if I had made decent choices in the past – something I had never even considered before.

My studies in the master’s programme went well but soon it was time for the biggest mental hurdle of them all – the master thesis. It represented half a year of work where I would have to use all of the skills I had learned during the past 4.5 years and package this into a compact project which had to have strong academic value, a report longer than any I had written before and conclusion that would help save the world. Or at least, this was my initial thoughts on the master thesis.

Master Thesis – do or die?

When it was time to find a subject for my master thesis, most of the companies I talked to were very positive on taking me in but none really presented an actual proposal on what I could do. Even though I might be creative in coding, I am not very good at trying to make up new projects from nothing which meant I needed some help to get started. Late in November, after meeting some Scionova employees at the Date-IT fair and later attending their meetup, I heard an amazing idea about bringing more cybersecurity into the field of smart homes. Soon the hype train was going and I found myself together with Lisa, whom I had done multiple projects with during other courses, towards a master thesis at Scionova. I remember going home that evening thinking, “Wait, that wasn’t so hard and scary?”.

After having some struggles with Chalmers administration details, particularly in getting a master thesis supervisor for our project, we finally could start the project in May 2019. It still felt a bit scary to maintain all parts of such a big project all by ourselves but it worked out nicely in the end. We got employed by Scionova somewhere in October and everything started to feel a little less stressed again. Suddenly I was not that stressed about leaving studies and entering the working world.

Getting rid of all the nervousness

In December I went to a consultant interview and it actually felt really good. I got to meet some people from the team and they seemed like normal human beings, the project did not sound like rocket science and somehow I started to realize that it would all turn out okay. One month later I started the assignment and now four months later it is hard to understand how I could feel so nervous about growing up and starting to work. It is actually even more interesting now since I can dive into challenging coding problems all day long and actually get paid for it. Work-life DO actually have some benefits!

 

Part 2: Studies or work life – which one rocks the most?

 

Time

This is probably the most classic thing to mention when comparing studies and work life but an interesting opinion of mine is that neither side has the upper hand. On one side, work life means free weekends and no responsibilities outside working hours. On the other hand, while studies might keep you busy on both evenings and weekends you do not have the same requirement concerning the amount of working hours. As long as you have learned what you are supposed to, you could actually take the rest day off to work on your hobby coding project, or go out to see the sun, or go out for a run, or…. Yeah, you get it. I miss the freedom in time management that studies bring but I definitely do not miss the stress.

Monetary assets

Another one of those classic aspects to mention is money. I am one of those people who do not spend particularly much money overall, which actually made it rather easy for me to survive on study grants and the cheap study loans CSN provides. However, one must remember that this is something rather unique to Sweden – instead of paying for education we actually get money to study. However, with all that said, getting a salary and feel that I can do anything is rather nice. Wanna buy that new cool tech stuff to integrate into your smart home? Wanna have both Netflix and HBO at the same time? Now it is actually possible!

Vacation

Chalmers last study period during spring ends around the beginning of June and the first study period of the autumn starts at the beginning of September, giving roughly 13 weeks of study break. Most students have summer jobs but those are usually rather flexible and is often an interesting contrast to study life. Personally, I usually worked around 6 weeks every summer, late June to early August, leaving 7 weeks of freedom. Working life is not quite as generous with 4 weeks leave in the summer to keep some days for the rest of the year as well. Amazingly long relaxing summers are definitely something I am going to miss.

Club activities (föreningsliv)

Student life outside studies is filled with activities, associations and other fun stuff that makes life really amazing. Unfortunately, this is not really the case for work life. It seems like people are trying to organize fun activities within companies, but it is much harder to get it going. When you think of it, this actually makes a lot of sense. Instead of having people in the same life situation with flexible schedules and apartments nearby attending your activity you will have to coordinate a mix of people in all ages, with or without children, with other hobbies outside work, etc. However, I love that AWs, celebrations and other nice activities still happen even though these barriers exist.. +1 to student life for all the activities but +1 to work life for effort!

 

 

Context-switching

Studies are all about learning new things and hence you never stick with the same courses and projects for a long time – do what you are supposed to do in the course, learn from it, move on and start with another entirely different task in the next course. As a contrast, work life is all about one big project that you are supposed to take from one less evolved state to another more evolved state during a longer period. You get to explore problems in its depth, feel the face slaps from your own errors coming back at you and enjoy the progress of yourself and your team when the code actually starts working!

Smart experienced people

I have had the luck to end up in a team with incredibly talented senior developers who have taught me so much even in this short time. This is something that sometimes is lacking in studies – most students are on the same skill level and you rarely get a close enough relationship to teaching assistants and professors to be able to absorb such knowledge effectively.Working in IT definitely means learning a lot of stuff!

Conclusion

So that was a list of differences and similarities between work life and student life. In the end though, who wins? For me personally, it is actually fifty-fifty with pros and cons on every front. Sooner or later you will have to transition from one to another and the most important thing to remember is that it does not get worse. Maybe different. But not worse.

 

Regards Matz