Introduction

Each year I post about what have I done in that particular year, inclining it more toward career. This is to document my process of learning over the year.

I know I’m too late for a year in review post, but every time I wanted to post, there was something more high priority coming up. Today I have somehow managed to finish creating a featured image and make an end to the post.

The Year 2020

So what was new in the year 2020?

Courses completed

1. Bits and Bytes of Computer Networking

The reason for learned was rooted from a Docker support channel on Slack. I went there to ask for help for the issue I was debugging. I was told by a gentleman to have a basic understanding of Networking. After doing this course I feel confident about Docker now. I know this course doesn’t teaches you everything, but at least it gets you started. I plan to follow teachyourselfcs networking curriculum when I find it necessary.

The course starts with an introduction to OSI model, then goes into each layer of the model explaining the protocol and application used in that layer. How a packet propogates from one host to another. What metadata each packet holds. Then the course talks about Networking Services in which it talks about DNS, DHCP, NAT, VPN and proxy servers. It then talks about how we connect to internet with wired and wireless connections. What wired and wireless protocols are available and all. At last it talks about commands which can be used to debug networking issues on Linux and Windows.

2. Operating Systems and You: Becoming a Power User

This is a course by Google, delivered on Coursera just like the above course. Although I knew most of the stuff taught in Linux, this course gave me exposure to do the same stuff in Windows. This course prepares you for system administration job. Things which are covered are Users and Permissions management, Package and Software Management, Filesystems, and Process Management. I won’t they doing this course will get you a job as a Systems Engineer.. but yeah, if you want to get into it, this is a good start.

3. Gophercises

Early in 2020 I decided to learn a new language and chose Go, because: a) It is good for backend. b) It is a good transition from Python. c) Many companies are already using it. Gophercises was one of the resource I was using. Other ones being Learn Go with Tests and rest of the internet. Go brings the easiness of Python and Robustness of C together.

Jon Calhoun believes in learning by doing. Gophercises comes with small exercises which deal with certain problem domain. It gives good exposure to language features that you will encounter later. Here is my code which I was working on: https://github.com/santosh/gophercises

5. JavaScript30

This is comparable to Gophercises in Go. It teaches by making us doing. It cover all new ES6 and talks new methods of doing things in modern JavaScript. One nice thing about this series is that it encourages you to se Vanilla JavaScript. Contents are, but not limited to topics such as DOM, CSS, audio, video, harware access.

4. First Year in Code

This book is comparable to The Pragmatic Programmer: From Journeyman to Master, a book I’m continuing reading this year. It’s just that First Year in Code is available for free. I find some chapters in that book relatable to me.

Techniques and Lesson learned

1. Exponential Backoff

While learning about and designing APIs I dwelled into exponential Backoff. Exponential fallback is when you hit an API and for some reason the server wasn’t able to fulfill the request. Now the next time you hit the API the server will make you wait for double the time of last time. Say I hit an API, it failed, I will have to hit the API after 1 second, next time 2, then 4, then 8 and so.

2. Cache Servers and Eventual Consistency

Back when I was a teenage, there already was concept like CDN. I use to download it using CDN only, there was no Node.js back then.

Now at this stage, I know the bigger picture, and how is it related with other development ecosystem. With cache servers we can reduce the load from our application server. There are concepts like cache hit and cache miss. User might be reading an older data, so data invalidation is important. I have seen eventual consistency when working with Twitter’s API, where the number of likes are not consistent between API response and web UI.

3. Distributed Computing

In distributed computing architecture, the systems work by passing message to each other. These are the more practicle architecture where systems are located at more needy locations than being located on one place. Say your traffic is coming from Japan, then it’s better to keep your infrastructure there instead of US.

There is a theorem called CAP theorem which says that a distributed database system can only guarantee two out of these three characteristics: Consistency, Availability, and Partition Tolerance:

• A system is said to be consistent if all nodes see the same data at the same time.
• Availability in a distributed system ensures that the system remains operational 100% of the time. Every request gets a (non-error) response regardless of the individual state of a node.
• This condition states that the system does not fail, regardless of if messages are dropped or delayed between nodes in a system.

4. Graceful Degradation

Design your system in such a way that not a single failure can take down the entire system. In other words, it is an ability to maintain limited functionality even when a large portion of i has been destroyed or inoperative. You can read more about this topic on Wikipedia: https://en.wikipedia.org/wiki/Fault_tolerance

7. Documentations, not videos

Back in time when I started ABCD of programming in school, I had not so fast internet connection, YouTube was not possible back then for learning. There were only blog posts and documentation. When I went to Delhi for Animation studies, that was the time internet was in abundance. From there I started a habit of rich internet resources like videos and all.

Now after a long time ago, I feel like documentation are the primitive stuff and are not going anywhere. Now I am again going back to the documentation and specs level. Specs tell the things which are not covered by tutorials. I have read about AMQ protocol and HTTP protocols (both HTTP/1.1 and HTTP2). Inspiration for this came from a failed interview where I was not able to properly authentication mechanism to a CLI application. And there was no clear tutorial for that all across the internet.

The Year 2021

Started and Ongoing

Following are the courses, books and topics for year 2021.

1. AWS Certified Developer

Started last year this is a course available on Udemy as Ultimate AWS Certified Developer Associate, still continuing on this in 2021. Shall be completing this by 2nd quarter of this year. At the time of writing this paragraph, I have completed 20/30 sections.

This is not the end, as I’m also planning to do a few mock test and apply for a AWS Certified Developer.

2. teachyourselfcs.com

Although I know a little bit about every topic in this collection, it’s better to follow them thoroughly so I can communicate with Engineering graduates better. This is the main content which I’ll be following for coming years. I have created a group on GitLab: https://gitlab.com/teachingmyselfcs. Although I’ll be following the main content recommended on the site listing, but suppose if there is any YouTube playlist I am following, it will go as a submodule to the course.

Books

1. The Pragmatic Programmer: From Journeyman to Master

I have completed almost 50% of the book at the given moment. This book is full of references that will make you a good programmer. The way you write code will change (if not already). The author is very good at taking anologies from environment and teaching the concepts. I will write a blog post with the review of this book when it is complete.

2. Rich Dad Poor Dad

I started reading this book when I was in college. I have learned about buying assets, not liability. More chapters to go.

3. Soft Skills: The Software Developer’s Life Manual

This book and the next book in this listing are the two books I would suggest any software developer who I meet in life. While The Pragmatic Programmer is focused toward software development only, Soft Skills covers the entire ecosystem related to software development. This book itself is written by John Sonmez who himself was a software developer. Among all of the topics, I like his idea about starting a blog and teaching people.

The thing is, when you teach some topic to other person. You first have to settle that concept into your life by keeping a reference of life event (of your choice) and the concept. It’s like one-to-one relationship or one-to-many relationship. The next step in teaching someone a concept is to understand what other person might have experienced in life which matches to your life. You could be having in-depth knowledge of a topic. But you can’t explain it to anyone, maybe you should work on interpersonal communications.

4. Computer Systems: A Programmer’s Perpective

This book about computer architecture is more inclined towards programmers. The point to note here is you may or may not have Computer Science background to read this book. In engineering colleges you read computer architecture books which are more inclined towards hardware production, this book strips that stuffs and only teaches you programming specific things. This book is part of teachyourselfcs curriculum.

Soft Skills

Time Management

Affected by John Sonmez content, I started to become a finisher, meaning that I had to finish the work I have started or either choose not to start the work itself. I also learned that I need to have a proper routine, or a semi-flexible one. I also needed to track the progress of my work.

Somewhere in the mid of the year, I started using Google Calender. Some of my routine work were migrated to Google Calender. From doing laundry to having a drink monthly, everything had a recurring reminder. And for non-recurring things as well. I learned how this systematic organisation can reduce stress.

Somehow I ended up in a company where Personal Software Process was enforced. Well, I wasn’t able to retain the position in the company, but it was good experience knowing that to analyse the time, you first need to track it. Inspired from this time management thing I started using Trello. The action items that I need to do in 2021 are already laid out in my Kanban board.

Communication

This one new thing I learned in my life. It is not important that people must also be knowing or have experienced things that I have did. Represent to people what they can understand. Raise the level of curiosity in them.

Few more communication tricks I learned was knowing what to communicate, this will help you stay on the topic and won’t make you appear boring to the other party. One more thing is to ask yourself, who is intended audience of the message.

If you are looking for a good resource to improve your communication skills, with a pinch of science is MasterClass by Neil deGrasse Tyson who teaches Scientific Thinking and Communication.

Conclusion

I would like to end this post with a shout out to some people which I’ve met recently in life. I would like to thank Mayur Amminbhavi for believing in me and approaching me with only 8 months of professional development experience and giving me such exposure to a multinational company. I followed my passion to become Fullstack Developer today. I aim to go in some tech giant in near future.

I would also like to thank Prasanna Kumar for being such a great companion. Lokesh Vishwakarma, who was in the same team in two consecutive companies.

In the new team I’m working with Abhishek Gupta and Maan Singh who are very kind for a newcomer like me in fullstack development.

Wrapping this year on a positive note, I really hope to learn even more next year. Here’s hoping for a great 2021 for everyone!