Interning as a software engineer at hSenid Mobile — Part II

I was really looking forward to putting up a follow up to my initial internship experience story, because now we get to the meat of the matter. It took me quite some time to come around … quite more than what I was expecting, since days have been long and tough as of late. This blog will comprise of my first hand experience of contributing to a large-scale industrial level software project, my learning experience with AJAX and some undoubtedly useful Linux commands.

Play time was over

I wouldn’t necessarily call it play time, but my training activities paled in comparison to understanding and contributing to an actual project. There were a considerable amount of projects available on GitLab, but I was initially given access to only one. Word around the place was that, it’s the ideal project for recruits to play around with, since the project does not directly interact with the customer. However, that single project was definitely enough to keep me occupied for the rest of my life, but thankfully the first task which was given to me seemed simple enough, or so it seemed. My spidey senses (peter tingle if you must) were already tingling when I was being briefed on what to do.

Apparently, there was a table residing inside a webpage, which could be populated with data, but there was no way of removing said data. My task was to add a delete button to each row instance of this table, and the functionality of it needed no explanation: it should delete the associated row.

Looks can be deceiving — my first official task

I was acquainted with Git at this point, so I created an SSH key and cloned the project. Followed by creating a new branch for the feature I was about to add. When I was volunteering for open source software projects, or working on my own projects, I was never consistent with branch naming; sometimes they were camel case, sometimes they were snake case and sometimes I stitched up words with dashes. I could not carry those practices to an industrial level project. The branch names had to state their purpose surely, but they also had to include the current sprint number and needed to be categorized as either a new feature, a fix for a bug or a NIT, which stands for nitpicking small changes.

When I opened up the project through my IDE, I was greeted by rows and rows of red underlines, syntaxes highlighted in red and hundreds, if not thousands of files. Understanding ‘where and how the APIs are used’ and ‘tracing method usages’ were off the topic with a project in this state. I couldn’t necessarily do anything to start off my task without properly configuring it to work with IDE. My supervisor at that time and a colleague provided me with the necessary JAR files and database dump files to get the project to a state where it could be built using maven commands. The built project could be executed on the environment through a TomCat server. As for the code itself, it was still very much red. I could not verify if the method calls which I were making were valid since the luxury of autocompletion was not available to a broken project. I tried regardless, to find where the table was being populated and traced a near identical feature to understand the code flow.

I made a breakthrough when I learned how to add a dynamic delete button per row instance, but was immediately let down when I realized the functionality was only capable of deleting the generated html row and the instance would come back when I refresh the page. I completely dismissed the fact that these rows were dynamically generated from a database and I had to fire an API call to “remove these rows for good”.

I had to turn things up a little. If I was going anywhere with this task, I had to make sure the configuration was done properly. I contacted one of my friends who happened to be an ex-employee of the company. The first thing she said was to start from scratch; Reload the project, reset the git branch or even removing and re-cloning the repository; whatever it took to make sure intellij was recognizing the project structure and that’s what I did. I deleted the local repository and intellij setting files, re-cloned and loaded the project back up. This time for some miraculous reason, the project was identified as a Maven project and the red lines were gone. When I tried to see the ctrl-click behavior of methods, it would lead me to the implementation. Everything seemed to be fine for now.

The next step was a whole nother ball game. I had to do what was called a ‘business patch call’. My supervisor mentioned this a few days ago but at that stage I only knew what a cabbage patch was. A business patch call is when the information from the current business instance is taken, the required information is altered and patched on top of the existing information. It’s the equivalent of doing a blood dialysis. That’s exactly what I did; I added a functionality to the delete button which would retrieve all the business information, remove the selected data group and replace the business information. It couldn’t be just the delete function when the button was clicked however. There had to be a procedure. I had to add confirmation popups using JSP files, information validations and confirmation messages. Most of it was for cosmetic purposes.

Completing the task was half of the problem. Now I had to commit these changes … except this wasn’t my pet project. No half baked commit messages nor arbitrary branch names were allowed and to top it all off, after committing my changes to gitlab, I had to write a release note about it. Yes … I have to relive my pain. Following that, I had to inform the QA team to test out the latest additions.

I only knew one Ajax, and he was Greek

This is the time where my supervisors switched and the task which I was struggling with was coming to a close. Right before I could lay that chapter to rest, I was advised to learn how to do the same task using AJAX. Carl Johnson's iconic catchphrase went through my head.

Spoiler alert! I couldn’t finish the task since I ran out of time, but I did however spent the time given following a Linkedin course which helped me learn the basics of AJAX. Let me run you through some of the important points I jotted down:

• AJAX stands for Asynchronous JavaScript And XML, and it is not considered a programming language.
• The basic functionality of it is to load certain parts of a webpage without refreshing the entire page. I for one would hate having to do that with third world country internet.
• AJAX takes care of the hassle by loading parts of a webpage in the background (by sending a request to a server and retrieving information) while the user is able to navigate through the rest of the content.
• The most common example would be google search, where the dropdown suggestions are generated with each typed letter without reloading the page itself. A simple breakdown chart is as follows:

Never ending commands and flags

Prior to getting accustomed with Linux based systems, I despised command line navigation. As a matter of fact, being a retro PC junkie, the aesthetic aspect of terminals was enticing to me but I always preferred the comfort of a GUI. After joining the company, I was forced to learn to do most things through the terminal. Believe it or not, I almost prefer it over GUI navigation now … almost. My love for Windows still runs deep.

It took quite a bit of time for me to familiarize myself with the most basic commands and I would like to share some of the commands that I picked up along the way, which I think might come in handy for you as well. That is of course if you are planning to try out Linux.

File/Folder altering commands:

Directory commands:

Archiving commands:

Permission altering commands:

Connection commands:

Disk space commands:

File reading commands:

Searching commands:

Other commands:

Please note that these are a few of many commands which you can try out. There are plenty of other sources online which you can use to expand your knowledge on Linux. I hope the commands which I provided would give you a head start. On my next blog I will be trying to cover my experience with writing bash scripts, remote server handling, working with android studio and a few other tasks which I managed to complete. Till then, Cheers!