Unlocking Knowledge: How AI Revolutionized My Learning Process

AI can be your guide, IF well used! - Generated by DALL-E 3

One of the biggest strengths of a good professional is continuous learning. There is no way we can maintain a position in the current market without any basic knowledge about technologies that are constantly being released. The good news is that the community and the industry are aware of this, and many tools have been developed recently to make this “mantra” a little easier to maintain: email subscriptions from the best knowledge providers in the industry, time for learning during work, developer roadmaps and many more. Today, I want to talk about using LLMs for continuous improvement.

The last significant technology that impacted our industry is forcing all developers to take control of it as fast as possible — LLMs or Large Language Models. LLMs are seen as essential for many use cases, increasing the need for fast growth for engineers. The good news is, it can also help with that growth!

I will show you how I recently used an LLM to help me determine my goals and reach them during a semester and how you can do the same! I used a proprietary LLM, but that result is achievable with any publicly available application—Chat GPT, Bard, Copilot, etc.

Continuous Learning

First, let’s remember some fundamentals about good quality learning that should help us determine what we want in the first place:

1. Specific, measurable goals: How can we know if we learned a topic if we do not even have a way to measure it? Make sure to add quantifiable activities to every step of your learning journey; otherwise, it will be very easy to THINK you know something when you really don’t. Seeing someone clone and use a repository through Git can seem very easy, but if you try it yourself for the first time, you will certainly miss some steps!

2. Specific dates: This one speaks with our latter point: you need specific dates to know you are making progress. If a date is coming closer and you are not close to your objective, speed up! If it’s the contrary, take your time with other activities. Your time is precious, never forget that. A goal without a time limit can become unattainable very quickly.

3. Make a plan that works for YOUR career: Everyone is different, and it is impossible to have all knowledge available on our big Earth. Make sure to set goals that will solve your problems in the near future and fill gaps in your knowledge that you feel will increase the quality of your work and your life. Sometimes, you can talk with your manager about this to better set these expectations, but at the end of the day, it is a personal journey in which you are the best guide.

The Planning Phase

Okay, so getting to the meat of it! I find that the very best way to learn something is to see a clear example of it. So I’m sharing my learning goals from the last semester! Seeing the gaps in my knowledge and things that I would like to get better at, I decided on a very technical set of goals. I wanted to have a first contact and get some level of intimacy with this stack:

• Kubernetes
• Docker
• Infrastructure as Code
• Django
• Microservices

Django is not my framework of choice by any means, but I had some previous experience with it. That made sure I could focus more on the other parts of the stack instead of losing time learning a new language and framework from scratch. The others I had some superficial knowledge but never really put my hands at work with them — that is what I wanted to solve here!

Okay, so how do we go from that list to a REAL, QUANTIFIABLE plan?

Here is my initial pitch for the LLM:

Give me a 8–15 step project plan[1], it must take 4 months[2]. 
The project's objective is to get acquainted with this stack[3]:
- Kubernetes
- Docker
- Infrastructure as code
- Django
- Microservices

The project is for an advanced developer, but the content of the project can 
be introductory, as the dev has no experience with this specific stack[4]. 
The project must start feb-15–2024 and end june-15 [5].

Here you can see I had a basic understanding of how many steps I would like a project of this magnitude to have [1], also based on the time frame of my growth periods [2]. The stack decision in [3] was explained previously.

LLMs tend to treat you as a beginner in all fields, so in case you are already an experienced programmer just looking for a new stack to get into, it is relevant to indicate that, like I did in [4]. Then in the end we have a final confirmation of that timeline we need to be working with in [5].

Here is the result I got:

Sure, here's an 8-step project plan to help an advanced developer get 
acquainted with Kubernetes, Docker, Infrastructure as Code (IaC), Django, 
and Microservices:

1. **Step 1: Setup and Orientation (February 15 - February 22)**
- Get acquainted with the terminologies and basic concepts of all the 
technologies: Kubernetes, Docker,Infrastructure as Code (IaC), Django, 
and Microservices.
- Setup development environment which includes Docker, Kubernetes, Django.

2. **Step 2: Docker Basics (February 23 - March 1)**
- Understand Docker, its architecture and its components (images, containers, 
Dockerfile).
- Create Dockerfiles to create images and containers and understand how to 
operate them.

3. **Step 3: Kubernetes Basics (March 2 - March 15)**
- Study the architecture and components of Kubernetes (Pods, Services, 
Deployments, etc.)
- Learn to operate a Kubernetes cluster using CLI.

4. **Step 4: Introduction to Django (March 16 - March 29)**
- Understand the Django architecture and MVC pattern.
- Create a simple web application using Django.

5. **Step 5: Docker + Django (March 30 - April 12)**
- Containerize the Django application using Docker.
- Practice using Docker Compose to manage multi-container Docker applications.

6. **Step 6: Kubernetes and Microservices (April 13 - April 26)**
- Learn about Microservices architecture and advantages
- Create Kubernetes deployments for different microservices.

7. **Step 7: Infrastructure as Code Basics (April 27 - May 10)**
- Understand the concepts and advantages of Infrastructure as Code (IaC).
- Get acquainted with IaC tools such as Terraform and learn to define and 
provide data center infrastructure using configuration scripts.

8. **Step 8: Integration and Testing (May 11 - June 15)**
- Integrate all the services together and ensure they work in synchronization.
- Perform various tests to ensure the reliability, security, and performance 
of the applications and services.

Remember, this is a learning project. The pace might be faster or slower 
depending on the developer's affinity with the subject matter. Adjust the 
timeline accordingly. Happy learning!

It is already pretty good but there were some changes I still needed:

- Add a dataset: the dataset used is GSO Weather Data - Weather data for 
Greensboro from 2010 to 2016 downloaded from DAYMET API [1].

- Add verifiable steps: add to each step what behavior can be verified to 
know that step was a success. Example "When complete: can access this api via 
localhost and read weather reports for a queryable location" [2]

- Let's start with the django API. I want to have something usable before I 
start working with IaC and docker [3]

[1] I did some previous research on free datasets and I was aware that this one was used a lot in multiple examples on the web. In the end I actually ended up using a movies dataset, which I found to be more interesting (I’m a big fan of cinema) and was also more adequate for the filter searches in an API. [2] it is very important to have verifiable steps here, otherwise there is no way to track real progress — you can think you learn something, but no way to be sure of that if you can’t put it in practice. For [3], I wanted to have something usable before I started working on the more complex features. That way I could always come back to the basic functionalities of the API to know if everything was still working properly.

And here is the final plan we got after these changes:

Here's the revised project plan:

1. **Step 1: Setup and Orientation (February 15 - February 22)**
- Get acquainted with terminologies and basic concepts: Django, Kubernetes, 
Docker, Infrastructure as Code (IaC) and Microservices.
- Setup the development environment to support Django.
- Verify that Django setup is successful and the developer is able to explain 
basic concepts of the stack.

2. **Step 2: Introduction to Django and Dataset Implementation (February 23 - 
March 8)**
- Understand the design of Django and the Model-View-Controller (MVC) pattern.
- Begin importing and implementing the GSO Weather Data set into a Django 
project.
- Verify that a basic Django application can be deployed locally and the 
dataset is properly imported.

3. **Step 3: Django API Development (March 9 - March 22)**
- Design an API using Django to expose the GSO Weather Data.
- Conduct local API tests for functionality.
- Verification: The developer should be able to fetch weather reports for 
queryable locations from the locally operating API.

4. **Step 4: Introduction to Docker (March 23 - April 5)**
- Learn about Docker, its architecture and how to use Dockerfiles.
- Verify that the developer is able to create, run, and manage Docker 
containers locally.

5. **Step 5: Dockerization of Django Application (April 6 - April 19)**
- Containerize the Django application and API using Docker.
- Utilize Docker Compose to manage this application.
- Verification: The Django application and API can now run inside Docker 
containers.

6. **Step 6: Basics of Kubernetes (April 20 - May 3)**
- Study Kubernetes, including its components and architecture.
- Learn about Kubernetes deployments.
- Verification: The developer can deploy services in a local Kubernetes cluster.

7. **Step 7: Kubernetes Deployment of Django API (May 4 - May 17)**
- Deploy the Django-based application and API in the Kubernetes system.
- Verification: The Kubernetes cluster can successfully manage the Django 
application.

8. **Step 8: Infrastructure as Code (IaC) Introduction (May 18 - June 1)**
- Understand the concepts, benefits, and tools of IaC.
- Learn to describe infrastructure setup and provide for a data center using 
config scripts.
- Verification: The developer can define a basic IaC setup using Terraform or 
a similar tool.

9. **Step 9: Implementation and Testing of Complete Stack (June 2 - June 15)**
- Implement IaC for the complete stack.
- Conduct integration and reliability tests for the entire system.
- Verification: All services work synchronously and the Django API is robust 
and fully accessible.

This plan reorders the original steps to focus on familiarization with Django 
and creation of a usable API before introducing Docker, Kubernetes, and IaC 
concepts.

Here it is! I was pretty happy with this final result and my manager too! So much that he recommended that I pass this information along 😉.

How to ask good questions

Using AI during the planning phase certainly helps, but it is also a very powerful ally while you are learning that new skill. I selected 10 of my most useful searches during the project to help reinforce this idea and show you how to ask good questions to a LLM:

1. What is the difference between Django and Django restful?
2. Explain and give examples to the use of MVC pattern in Django specifically in the context of Django Rest Framework
3. Explain Django’s MVC pattern. Give some examples for each. You can use the application theme of Letterboxd as an example (web app for giving score to movies)
4. I have a Django application with a sqlite3 database. I want to containerize it using Docker. What is the process to do that?
5. I have a Django setup working on my computer inside a Docker container. The idea is to release that on Azure at some point. How can I leverage Kubernetes in this project? IAC is welcomed.
6. How do I build my Docker image using docker-compose?
7. How to check the status of my Kubernetes services using kubetcl?
8. What does “ready” and “available” mean in kubectl “get”?
9. What does container port stand for in deployment.yaml for k8s?
10. how to add an external IP to my k8s cluster hosted in Azure?

While these examples may not apply to your specific topic of learning, they can certainly give valuable insight into how to ask good questions. In my experience with LLMs, they are the most useful in the stage where you don’t even know what question you should be asking. Trying to work with that level of knowledge in a standard search engine like Google or Bing was a big pain, but LLMs really help you understand a bit of the context and get closer to that specific question you really need to be asking but do not have enough background to reach.

Try to always give some background of your project before asking the LLM questions to get better results. Be aware these details will go public depending on which LLM you are using though, so never send information protected by NDAs.

Final thoughts

I hope this post inspires you to also leverage LLMs in your personal growth and maybe other projects where you need to apply milestones and generate these written outputs. I firmly believe technology should always be aimed at making our lives easier and decreasing the amount of noise and repetitive work we have to deal with in our personal lives and work activities, and using AI with my growth indeed reduced a lot of this repetitive, challenging work in the learning process 😊.