How to Learn the Essential Developer Skills to Kickstart Your Tech Career
With the software industry growing so swiftly, it is becoming really tough for developers around the globe to keep up with the pace. Even if you are really talented, hard-working, and motivated, things can go laterally if you are unable to keep up with the standards of the current industrial trend.
With software development becoming an area of interest to a wider crowd, several tools and software applications have been launched into the market to enable higher coding standards to achieve better, and more importantly quicker development time. Having some of the required tools at our disposal along with a good internet connection (remember despite so many tools out there, Google is still your best friend :P), development is not a very hard task.
But since there are innumerable tools out there, selecting the “BEST” becomes a challenge.
With the Cloud technologies hitting the sky, most of the product based companies have started to migrate their codebases to the Cloud. What do we need to know to work successfully on the Cloud?
90% of public cloud computing services run Linux. A competent software developer must know how to use a Linux system comfortably. When you create your own Linux virtual machine from services like GCloud, AWS, or Microsoft Azure, you don’t usually get access to a Graphical User Interface (GUI). You have to use the Linux terminal to operate and manage your server.
Most of the software companies encourage teamwork, so you will require to work in a team. This is where the need for Git pops in.
Learning Linux finally has a valid reason now. Shifting from the colorful, interactive and, attractive Windows OS to Linux can be a nightmare for most of us. But if you can survive the first few weeks, the eventual returns can be very fruitful. You will never want to go back to Windows after experiencing all the power that you have with Linux unless of course, you are a gamer :P.
So I decided to learn these essentials to try and have a productive lockdown. Browsing through the internet, I found that Crio.Do was hosting the September Edition of #IBelieveInDoing which comprised of Linux and Git!
The entire challenge was divided into three bytes (each byte is a set of milestones, and each milestone focuses on a particular topic): Linux Basics 1, Linux Basics 2, Git Basics 1. It started with a kickoff call which was as interesting as interesting could be. We were shown the power of Linux in a mere duration of one hour. The call moderators showed us some interesting things we can do using Linux like running a bash script, creating a two-way chat application using netcat, and how to tweet using the terminal!
This motivated all of us to actually take up the bytes. I will share a summary of the bytes involved.
Linux Byte 1
The biggest challenge while starting this byte was to get access to a terminal because many of us did not have access to a terminal. Crio was considerate enough to find an alternative in form of gitpod given that not everyone has sufficient computing power in their machines/internet resources to set up a Virtual Box or Dual Boot for Linux.
This byte started with an introduction to some basic commands like:
- pwd — To print the working directory.
- ls — To list the content of a directory.
- cd — To change the working directory.
This byte went ahead in a very interactive way teaching us the right way to use the commands. Every milestone had a set of questions in the end which were out of the box and made us think before answering. These questions made sure we experiment and Google well enough in order to answer them. Each milestone also had a section called “Curious Cats” which had a few extra questions/tasks to try out for the ones who were interested in trying new things.
The last milestone was the most interesting one could ever find. It included data analysis on some of the common log files like Hadoop, Openssh, and Apache logs. These are some of the basic skills that will give a fresher a major kick start in the industry because most of the people learn such analysis techniques only when they start working for the organization.
Engineers besides intelligent, motivated, and smart are extremely lazy (Okay, somebody had to say it!). So if an engineer is required to do a task on a daily basis, he will put effort into one fine day to automate the process and relax for the rest of his life. We were taught how to achieve automation on repeated tasks by using chron and chrontab in Linux.
Git Byte 1
Every developer in the starting phase of his career has been in this situation:
- You badly need your old code because you have broken the new code way beyond Ctrl + Z.
- You get confused about which version of the code to use because your workspace has directories like project-backup, project-backup-final, project-ok-this-is-final-code.
- You have to integrate some of the code that your team members have written without breaking down the entire code.
- You need to keep track of why a particular change was made and by who.
Version control systems help in these situations. They help us keep track of changes to our files by taking snapshots of them. We can look at earlier snapshots and also restore our code to an earlier snapshot. This lets us work on our projects without worrying about introducing errors to partly/completely working versions and not being able to go back.
Git is one of them, probably the most popular one.
This byte teaches us how to setup git — either by using SSH or HTTPS, both having its own advantages. We are made to explore the entire working structure of git through commands that initialize a repo, clone a repo, make some changes in the local copy of the repo and push it onto the remote, and so on. This byte makes sure you get “git commit” in your memory permanently :P
After acquiring the superpowers of Linux and Git, what is the first pet project you can think of? Hint: With Linux, you can keep track of when a file was modified last and Git can act as a storage for the newer versions. Think hard!
You can build your own simple version of Google Drive!
Researching about a few options that I could use to design to make my own Google drive, I came across two ways to implement it.
- A tool called inotifywait efficiently waits for changes to files using Linux’s inotify interface. It is suitable for waiting for changes to files from shell scripts. It can either exit once an event occurs, or continually execute and output events as they occur.
So my idea was to create a script with inotifywait in a loop so that whenever the file into consideration changes, we need to perform a process that adds the files into staging in git and successfully pushes it. Attaching the pseudo-code for reference:
(Notice how I have added the ‘date’ while committing, this is not necessary but it a good programming practice to drop in some metadata to distinguish the commits :) )
2. We can create a script that checks whether the contents of a particular file have been modified or not and when modified, it pushes the new content to the remote. To automate this process, we can add the script to our chrontab (stands for chron table, it is the set of chron jobs that run where chron jobs are daemons that run at every schedule it has been assigned for eg: every 5 mins, every hour, every week, etc)
These were the ideas I could come up with to implement a simple working version of Drive. Also, I have just added the check on one particular file. This idea can be extended to keep a watch on an entire directory or the entire system itself. There could be numerous ways to do the same, feel free to drop a comment.
Here is a short glimpse of the working of my code just for demo:
After learning these skills, I tried out some cool skills in Linux:
- Watching star wars movie in terminal:
sudo apt-get install telnet
2. Quick prototyping of ASCII images on the terminal:
sudo apt-install aview
3. You can use the ‘!!’ operator with root permissions (sudo) to run the previous command as admin! It always happens to me that I wanna run some command but I forget to use ‘sudo’, this trick will save a lot of tedious backspacing and spacing :)
apt-get install <something>
sudo !! -> Same as sudo apt-get install <something>
By the end of this challenge, you would have been able to get past the fear of the terminal and Git. But this is not it, technologies are highly volatile, you will forget how to use them if you don’t use them often. So, pick up any toy example either from the internet or from your personal life and start applying these skills openly :)
To conclude, this edition has turned out to be a game-changer for me. I hope that this is a mutual feeling to other developers who took up this challenge as well. It was completely worth every minute that I put into the challenge. I encourage many more young developers to participate in the future editions of this challenge as it can boost the way we start our careers.