Blog Misc

Jr. Software Developer – My first Work Internship

“Be careful, because the code you write might set your pc on fire.”

This is the warning that my tutor gave to me at work.
When I had first heard that, I laughed at the sole possibility of something like that happening, even though deep down I knew she was right. 
Well, it is either that or my head exploding first.  

After a pretty intensive job search, I was able to get myself a three months internship in a company located in Bergen, as a Junior Software Developer.
I am glad I got this opportunity for a few reasons.

  • The first one is that I finally could enter the so-much called “Norwegian Bubble”(read The Social Guidebook to Norway to understand what I am talking about).
  • The second reason is that learning programming and software development directly on the field is allowing me to learn at a fast rate. 

Before the start of my arbeidstrening I felt pretty nervous, but I was then given a warm welcome by everyone part of the ValveWatch development unit.
Taken from the official website:

ValveWatch® is an automated, online valve monitoring system for critical valves and actuators brought to you exclusively by MRC Global. Users can remotely monitor a valve or actuator’s performance and correct degradation before it effects safe and reliable operation.

The same day I was then shown around and given documentation regarding safety at work.
I was surprised by how big the company building in Bergen was. Hopefully I will have the time to see all of our equipment in action.
The work day is a flexible 7.5hrs per day.
I am glad of the flexibility, because my work commute is long and has multiple intermediate stops. 
There also is a 30 mins lunch break and a cafeteria where you can take food. 
The company also includes a small gym.

Finally, I received a top of the line PC station (Threadripper 2950X and a triple monitor setup) and office furniture.

If you think this hardware to be overkill (especially considering that the software being developed does not have any complex graphical effect) then you haven’t experienced the great pain of building time.
I am not kidding: it takes me around a minute for the software to finish building.

During my development journey at MRC I learnt appreciating Stack Overflow as a documentation resource.
Stack Overflow is a programming-focused forum where developers can discussion development issues. 
You can find material that varies from beginners to expert levels of complexity.

It can happen to have a roadblock while programming.
I usually look up online for people that might have been in the same situation as me. 
It is a fantastic feeling when you see on Stack Overflow someone posting the same question that you have had in your mind. 

It is a little bit less nice when the same person is able to fix it on its own without explaining how:

These are the tools that I have been getting accostumed to:

QT is an IDE. 
In more simple words: It makes your life easier by including everything you need to develop under one and united roof. 
One of the benefits that probably all IDEs include, is error checks.
If for example you do not correctly write down a line of code, the IDE will inform you of that (and might give a possible solution too).

Practical example. 
I wrote the following line of code: 

int variableName = "Sentence here";

Since it logically is wrong, the IDE will inform me of the error, on the same line where I wrote the faulty code. 

Mistaken variable declaration.
I declared a variable that is supposed to store numeric data, and assigned the characters “Sentence here”, which are letters. Therefore, I get an error informing me of that.

GIT is a piece of software that tons of individual or groups of developers use to keep track of all the changes performed to the code base of their software. 

It is text interface based, but some of its functions are packed inside QT’s UI. 
I could for example “commit” my most code recent changes, and if I regret it afterwards, I can undo it by downgrading to a previous commit of my choice.
It works kind off like Apple’s Time Machine. 

Another useful feature of GIT is that you can see what’s between each “change” you have published and what code has been removed or added.
This is good in case you need to compare the code between each version. 

There also is a “branches” feature. 
It allows a developer to “clone” the current project, and then add a list of features to that specific branch. 
By doing so, each developers can work on their own branch with their own features and then merge everything together. GIT automatically handles all of that.

GitLab is a web platform based on Git and made for team development. 
You can see in detail all changes made to the code, and approve merging requests with the rest of the code base.

Atlassian Suite contains several web products aimed at developers. 
We use Jira and Confluence.

  • Jira is a task manager with lots, and I do mean lots of advanced settings. 
    It is helpful for self-managed tasks and to see how other members of the team are doing at the same time. You can put advanced descriptions for all tasks, and keep tracking of how much time you are spending behind one. There is optional integration between Jira and Git. 
  • Confluence is, in short, a Team Wiki for share documentation. 
    The web editor is highly advanced and you can create nice looking pages. Of course snippets of code are supported too. 
    The dev team guide on how to setup the development environment is in fact written on a Confluence page. 
    Since I encountered a few problems due to software updates, I could report snippets of it or just fix them myself.

Something that I found interesting was how we were going to communicate with each other.
Each developer has a huge office desk, a side table and their electronic equipment.
Since we all are facing against each other, it is not always easy to show the code we are working on. 

So, when we are working on code related issues, we use a real time chat application to share code snippets. 
We also sometimes share our PC screen so that other people can see what is going on over QT. 

I believe this to be an effective way of helping each other because it does not disturb other people that are focused on their own tasks. 
Less details will be lost during the conversation too. 
The office is great too.
It has everything you’d expect from a good workplace: a lot of space to move, a coffee machine, whiteboards to write on, a ‘break’ area, 

I want to focus for a moment on the workplace culture in Norway.
People are most passionate about their work here, but they also like to socialize while taking a few breaks here and there.
As long as you do your work and do not slack off, it is okay to take some time to breath. 
It avoids mental exhaustion by letting people relax for a few minutes and It helps coworkers to get to know each other.
The other ‘big’ moment to socialize is our half-hour lunch break.
We got a cafeteria with a selection of food that changes every day.
Unlike countries such as Italy, the lunch is NOT the heaviest meal of the day.
You can either take a few slices of bread and put something on top (Norwegian salmon is
HEAVEN), or a small packed meal. You also can pick up some fruit and a small dessert. 
All the food that is not taken will be recycled (at a farm I suppose?), or can be brought home. 

There also is a balcony where you can sit down and enjoy the weather. 
It makes you feel one with nature. 


This Covid pandemic hit hard on many people’s lives.
Mine included.
It limited my mobility to come back home in Italy and profoundly affected my mental health.

It also hit a lot of industries worldwide, and 200 thousand Norwegians lost their job as a consequence
Right now, Norway’s population is 5.328 millions. 
Almost 4% of the Norwegian populations became unemployed. Luckily NAV (Norwegian Labour and Welfare Administration) gave financial support to many people that needed help. 
While receiving unemployment benefits, my salary was slightly boosted due to the current Covid situation. 

So yeah, thanks for the help NAV! 💖💖

It felt great to finally be back in society, and in such a productive environment too. 
No matter where I look, I always have something new to learn.
And no matter how many times I ask, there are tons of people willing to explain to me and help me understand new things.
My tutor has been extremely dedicated into teaching all that I have learned so far here. 
Even though this is a software development internship, the department also has engineers that work on hardware solutions too. 

I am going to summarize everything that I have learnt here so far, week-by-week.

First thing I did was to set up the development environment on the machine provided my the company. 
As development environment I mean the OS and all the programs that a developer uses to work. 
In this case, my dev environment features an SSH Key, LLVM, Oracle Instant Client (allows application to communicate with a database), Git, QT, CMake, Java, some C++ APIs

I did have some roadblocks during the set-up phase caused by some libraries lacking on my development machine. I fixed them and updated our internal set-up documentation before proceeding.

I opened for the first time the ValveWatch codebase in QT Creator. 
I made a fast UI sketch of the CSV parser window I would have worked on as part of my project, and I afterwards had to create a new entry in a contextual right click menu. 

Example of Brave’s right click contextual menu.

QT allows you to connect code and UI elements both through its GUI and/or code. 
Something that I quickly learnt during my internship is to always prefer using the terminal rather than its graphical counterparts. 
The same concept applies for stuff like that.
Especially when unexperienced. 

I remember that while learning Python I was looking over how to create a basic interface for my BMI calculator (which BTW I am recreating in C++, you can see it on GitHub!) and felt discouraged regarding how to proceed. 
QT handles all of that stuff (at least for basic projects) on its own.

I created a button to select a file, and interfaced it with Windows Explorer’s file select GUI, and storing afterwards the full directory of a selected file in a string. 
By then, I could interface the string holding the file directory to the CSV parser.

My first taste of parameters-argument was when some data was being passed from the Client to my pop up window. 
A parameter is a variable sent, while an argument is a received variable. This is especially useful when calling functions through other functions. 

Finally, I learnt how to manipulate arrays and vectors to import the CSV data inside the computer memory. 

During my arbeidstrening, I took a 2 weeks break for a car trip I had planned before (I needed my head to rest for a while), and shot the video “Cæsar og Charlie“.

Coming back to work, I mostly did refactoring of my already existing code and we implemented a new CSV Parser API, since the previous one was deprecated.

Something that gave me some trouble during July was when I suggested to switch the CSV Parser API we were using because our previous one was deprecated.

The API’s purpose is to parse a CSV file containing recorded data.
Initially the challenge was to get the CSV parser to count how many “sensors” were inside the CSV file. Well…
Hold and behold. With the new CSV Parser the only necessary part of code is this:

csv::CSVReader csvReader(file_dir.toStdString(), csvFormat);
csv::CSVFileInfo fileInfo = csv::get_file_info(file_dir.toStdString());


This still shows a huge lack of knowledge by me regarding how to read API documentations.

Finally, the last part of month two was featured by the introduction of Debug mode. 
Debug mode allows you to see when and where things are going wrong while your program is being executed. 

This is how it works: 
On the code edit mode, you can set breakpoints on the line counter on the left of the program.

I have spent most time of the month by refactoring (optimizing) my code, slowly adding UI functionalities to my program and discovering QT classes.

As of right now, I felt confident enough to just drop for a little bit of time my coding sessions.
I first put my hands on making a full inventory of all the laptops and docking stations that we have in the office.(btw docking stations are way more useful than I thought, especially if you have to take your laptop with you for a meeting)

To do a full inventory I have turned on each laptop, performed an hardware diagnosis and made a system info export that was afterwards uploaded on a Confluence page. 
The document featured a list with each laptop serial number, product number, basic hardware and charger info. 

Then, I focused on learning how to use the 3D printer we have in the office, a Creality CR-10S Pro v1. 

A 3D printer is used in such a way that you download a 3D model (for example from Thingiverse), and you use a dedicated software afterwards to converts it to a set of instructions that your 3D printer can interpret: the GCODE file format.
The 3D printer is not really away of how the end result is going to look like. 
It just knows how to move on its three-axis, the printing speed, temperature and other important settings that will vary depending on the level of quality of the final print and what kind of setup you have.
I expected 3D printing to be easier, but it actually requires you to sit down for a few days and learn how to properly calibrate it. 

Or weeks.

Well, me and another new guy wanted to perform some 3D printing tests, but the end results had plenty of inconsistencies. 
I am talking about stuff like this:

Image of 3D Printing Troubleshooting: Common 3D Printing Problems and Solutions: Gaps Between Infill and Outer Wall (Source)

On the right side of the print, you can see some parts not filled. We either got this problem or sections overlapping. 
While looking at the 3D printer on-screen menu, I mistakenly pressed the ‘Levelling’ setting’.

You’d assume to then access a menu with calibration settings, right?
You couldn’t be more wrong. 
This 3D printer is instead going to perform an automatic levelling test (distance between the muzzle head and the 3D printer bed).
Due to its previous non-standard configuration, the nozzle head ended up crashing against the printer bed, and caused the sensor to move.

Since I could not find any info in our internal matrix regarding such a situation, I decided to try things on my own by creating additional, new documentation explaining how to calibrate all the parts of our 3D printer.  
As of time of writing, it is split in these sections: 

  1. Gantry Frame Levelling
  2. Sensor Levelling – Part 1
  3. Sensor Levelling/Muzzle head adjustment – Part 2
  4. Bed levelling – Manual
  5. Bed Levelling – Automatic
  6. Muzzle temperature Calibration – Manual
  7. Speed calibration – Manual

Each of these components require specific and unique steps, which have been complemented with extremely high quality graphics made by me (© ®™) such as this: 

I am the Gordon Ramsay of art, but better.

In the end, the 3D printer calibration was successful. 
To better push my luck, I have tried printing multiple items in a single session. 
This is not a good idea because the 3D printer is taking care of one “entire” layer at a time, and 3D printing relies on material temperature manipulation. 
By printing the layer of one object, and then moving to a second object you are interrupting the current build. 
In the long run this will cause the final print to not be perfect, or even worse to completely screw everything up.

Apparently this is what happened during my last 3D print: some filament must have gotten stuck to the 3D printer head while becoming stuck, and crashed against the items that were being printed. 

I came back to the office the next day, I was welcomed with the 3D printer glass bed on the floor and a printing result that looked like it came straight out of “The Thing”.  

Going back into development, my tutor held a general OracleSQL course explaining how a database works and how you can interact with it (for example how to fetch data inside the database).

Knowing how to ‘communicate’ with the database was fundamental for my project and EventImport functionality, and it is overall good programming knowledge. 
Unlike C++, OracleSQL uses a different writing syntax. Something I find confusing is that they both use the same characters (for example –> ‘ )

Once again, I was surprised to see that QT has some sort of SQL integration through qSQL classes.
You can put SQL commands inside QStrings, and QT is going to handle the communication with the database.

It was interesting to participate in code reviews of my colleagues (mostly featuring my tutor’s code). 
Needless to say, even then I felt very overwhelmed by all of the code lines on the screen. It is also hard for me to read another person’s code (especially if without comments explaining the content) and understand what it does.

Close to the end of the month, only three things were left to do: 

  • Implement Event Import‘s communication with the OracleSQL database
  • Do as much refactoring as possible and split the program functionalities in three UI buttons
  • Create a Confluence introduction page of Event Import featuring the most common user-case of importing a .CSV RAW file. 

The tasks were completed on time, but not by much of the deadline margin. During the Event Import introduction I held in our department, the team responded well and expressed their interest in seeing it in action.

Final thoughts.

I am grateful for the level of teaching quality that has been provided by the company (and my tutor) during these three months of internship (arbeidstrening).

I am proud of everything I have been able to learn, but I am not satisfied with the end result that I have produced. 
It took me too much time to catch up with the topics I was studying, and my fear of ‘disappointing’ my tutor greatly altered my final performance.
It did happen a few times that I arrived late at work as a consequence of my fear stressing me out at home while I was supposed to be sleeping for the next work day.  
I have learnt how to manage this fear, and that it is okay to say “I need to slow down, I can’t follow up”. 
Or that I did not understand anything of a certain topic. 

Nether less, it is a great feeling to know that I can now make a GUI desktop application using QT, while interfacing it with SQL and with other third party libraries (such as the CSV parser I have used).
It gave a great boost on my CV and my professional confidence.  

I have been fed, taught and well-treated by my tutor during my three months permanence and I have now started an extra 6 weeks internship for a second project in the same company. 
Unlike the previous back-end project, this one shifted to pre-R&D. My objective is to record data proving how the lifespan of an in-house electronic device can be greatly extended. 

I am planning on writing a summary post for the second internship project and next time I will be more prepared through more detailed writing and notes.

Thank you R. and A. for being my teachers and aspiration on how to be a good developer. 
Having great teachers makes all the difference in the world when learning a new discipline.