My Regret

One thing that I regret a lot is diving directly into learning what people call “specialized tech” (for me, it was AI) before understanding the fundamentals of SWE. Why was that a mistake? When I started learning about and building AI projects, I realized that I didn’t know the fundamentals of a lot of things (Git, GitHub, OOP, etc.) that I required for building those projects. The tutors of this “specialized tech” often tend to skip teaching fundamentals, assuming that the students are already familiar with them.

The Roadmap

STEP 1: The Programming Fundamentals

The first step in your SWE journey is to choose a programming language and to be good at it. How to choose a language? Choose a field that seems cool to you. For me, as I said previously, it was AI. So, I started learning Python. For you, it could be blockchain, so you could start learning Rust. The goal in this step is simple: to choose one and to ace the fundamentals. Understand this: learning multiple languages doesn’t make you great (or maybe it does, but not always). Learning one and acing it makes you great!

The fundamentals mostly include the following:

1. Data types provided by the language: strings, numbers (types of numbers), arrays (or lists in some), dictionaries, and sets—every data type that the language provides. Also learn the operations between the data types: mathematical operations on numbers, concatenation of strings, reversing a string, searching through a list (using list methods), indexing and slicing a list, etc. Try to explore as many operations as the language offers.

2. Building simple logic-based projects (like a calculator, a cuboid’s volume calculator, reversing a character, a mark-sheet generator, etc.) You can also look for simple logic-based problems in HackerRank.

3. File I/O. How to open different types of files? How to read an existing file? How to create a new one? How to modify an existing one?

4. Using an existing library/framework. For this, I’d suggest you choose a cool one (for me, it was Pygame, through which we can make games in Python). Learn how to install a library/framework, how to import it, and what type of magic it does in your code.

After exploring this, I believe that you’re good to go to step 2.

Side learnings in Step 1:

In the first step, while learning the things that I mentioned above, you can also explore:

1. Git/GitHub: You’ll need this to collaborate with others in the future, so this is a must for any developer.

2. Reading a little bit of documentation: Memorizing gazillions of syntax and methods is not possible at all, no matter how professional of a tech wizard you are. So, you need to start learning things by reading documentations. Nowadays, AI tools like ChatGPT have mostly replaced documentations, but I still suggest you go through documentations and try to understand them.

STEP 2: The Exploration Step

In this step, I’d suggest you look mainly into two things: OOP and APIs.

1. Why Object-Oriented Programming (OOP)?: Although there are some people who say that OOP introduces a lot of unnecessary complexities, I’d absolutely suggest you have a look into it. I only understood the greatness of OOP after I learned it and actually used it. It allows you to write scalable and easily maintainable code and remove something called ‘tight coupling,’ which means that a part of your code is fully dependent on others and changing one leads to restructuring the entire project. OOP introduces you to things like ‘Duck Typing,’ code architectures, etc., that allow you to write loosely coupled code. Want to change the whole database of a huge project from SQL to NoSQL? Just change a single file (or a maximum of 3) and you’ll be good to go instead of rewriting the entire project. You get the idea.
   However, if the cool programming language that you chose in step 1 doesn’t have OOP, you can skip this part. But I won’t stop talking in favor of OOP!

2. APIs: APIs are everywhere. The Instagram story that you posted, the LinkedIn job that you applied to, and this blog that you’re reading are all possible due to APIs. So, I believe that learning the workings behind APIs, how to use them, and how to actually build your own API is the most important thing. It is something that you WILL need no matter which ‘specialized tech’ you choose. You want to deploy your AI model, you will need some sort of API for people to use it. You want to learn hacking, you will need to first test it in your own API. It is simply something that you shouldn’t skip.
   Start simple. Learn about using someone else’s APIs, and learn about libraries in the language you chose that allow you to build APIs. Then learn to integrate a database into your API, making your API secure, and deploying your API with the tools required for it. If the cool language that you chose was Python, I have a great resource for you: This one!

Side learnings in Step 2:

1. I think it’s the best time to step outside your comfort zone and to choose a language different than what you chose in step 1. If you’re working in Python or JS, I recommend you choose C to understand how things in Python and JS work in C. You don’t need to grind the other language; just learn how things are done and done properly without causing an explosion!
   I think learning some other language (especially something lower level than what you’re currently doing) introduces you to a whole new world: a lot of technical terms you’ve never heard before and a lot of things that you didn’t know how they worked.

2. Talking about stepping outside the comfort zone, I think it’s the perfect time to learn Linux. You’re just learning the deployment of your API, so learning Linux at this step will definitely help you in that part. So, throw Windows out of your window and install Linux (or you can dual boot if you don’t feel comfortable completely abandoning Windows). Or, install it in a VM if you’re using a Mac.

STEP 3: Exploring the Specialized Tech + DSA!

1. Now is the time to go into your favorite specialized tech! Again, start by acing the fundamentals through some course videos. Then, read (or at least try reading) research papers on the fundamental algorithms that are popular in your specialized tech, and implement them from scratch! (scratch = not using any libraries that provide readymade implementation of the algorithms.) Then, you can read books to go deeper into the cool and magical world of your specialized tech! But don’t forget these golden words on every step of your path: ACE THE FUNDAMENTALS!

2. Start studying Data Structures and Algorithms (DSA). This is something that your interviewer will definitely ask you in your job interview, so you must know it. DSA will also help you build logic in your specialized tech field: which data structure and algorithm to use in what case? Do we prioritize performance or cost in this particular task? Is it even worth using this heavy algorithm for this light task? Learning DSA will help you solve these questions! Also, don’t forget to solve DSA problems in Leetcode!

Side learnings in Step 3?

I think, at this point, you’ll exactly know what you want and what you have to learn side by side, so you probably don’t have to take my suggestion on this one!

Extra tips!

1. Be curious and ask every question that comes to your mind! You may think that people will judge you, but honestly, they won’t. And it doesn’t matter even if they do! It’s for your betterment.
   By being curious, I mean ask stupid questions, ask genius questions, ask this question, ask that question, but don’t stop asking questions. These days, chatbots can help you with questions, but I suggest you ask a real human! This way, they’ll provide some extra piece of advice that comes from their experience that ChatGPT won’t.

2. Document the learning process. If you’re comfortable sharing blogs of your learning, you can do so. If you’re not, write notes. This will help you in two ways:

   1. You’ll have something to quickly revise if you forget something.

   2. You memorize things quickly if you write them down.

3. Mentor others. Teaching others the concept you learned will help you in two ways:

   1. It’ll revise your learnings.

   2. If your mentees ask some question that you never expected, it’ll force you to experiment more, learn more, and become more curious.

4. Build real-world projects and push them to GitHub. This will help you in two ways:

   1. Understand real-world problems, which gives your recruiter an impression that you will be able to work for their problems too.

   2. Sharpen the skills you learned by implementing things practically.

5. Contribute to open-source or voluntary projects. This will help you in two ways:

   1. Develop your team communication skills and let your recruiter know that you are a team player.

   2. Understand the code that someone else has written. And I think this is a more important point than the one above.

Ending Notes

This roadmap that I have provided above would work pretty well for me if I followed it from the start. But your scenario might be different, and you might want to make adjustments to this roadmap, and it’s completely valid! Do your research, play around with things, and make as many adjustments as you want to this!

Among the AI buzzwords that we've been hearing a lot these days, "RAG" is one of the most common ones. Also known as Retrieval Augmented Generation, RAG is a technique used in natural language processing (NLP) where a language model is combined with a retrieval mechanism to generate more accurate and contextually relevant responses. The idea is to augment the generative model (like GPT) with information retrieved from an external knowledge base or corpus. In simpler terms, RAG means storing external knowledge (such as information about a company for the company's chatbot) on a storage service (usually Vector Databases) and retrieving that knowledge and providing it to LLMs as context to get more accurate and relevant responses.

How does RAG work?

Refer to the flowchart above while reading this for a better understanding.

1. Data Sources:
   • It starts with structured or unstructured data (e.g., text files, PDFs).

2. Chunking:

   • The large text data is split into smaller, manageable chunks for processing.

3. Embedding Model:

   • Each chunk of text is passed through an embedding model to generate numerical vectors (embeddings) that represent the meaning of the text.

4. Vector Database:

   • These embeddings, along with their corresponding text chunks, are stored in a vector database.

5. User Query:

   • When a user submits a query (e.g., "What color is apple?"), it is also passed through the embedding model to create a query embedding.

6. Retrieval System:

   • The system retrieves the most relevant text chunk(s) from the vector database based on the similarity between the query embedding and stored embeddings.

7. Context to LLM:

   • The retrieved chunk(s) (e.g., "Apple is red") are provided as context to the Large Language Model (LLM), alongside the original query.

8. LLM Response:

   • The LLM processes the provided context and query to generate a relevant, accurate response (e.g., "The color of apple is red").

Why do we need RAG?

Looking at the workings of the RAG system, you may have a question: Can't we just provide the context to LLM in the user message? While doing this might work if the data is small, this doesn't usually work if the data is large, mainly due to the context window limit of the large language model. This simply means that the language model can't process an input prompt of token size that exceeds the context input limit of the model (for example, the context window limit of gpt-4o is 128k tokens). So, the RAG system solves this problem by providing small but most closely relevant context to the language model.