About AWS DeepRacer

A contest that is discontinued after this year, unfortunately, DeepRacer is arguably the most entertaining service available on the AWS Console today. This is the arena where you can train a virtual car to run through a racetrack, and the challenge is to complete 3 laps as quickly as possible without going off-road.

—

Before I get to the jargons, let’s first try to understand

What is Reinforcement Learning?

Reinforcement learning (RL) is an interdisciplinary area of machine learning and optimal control concerned with how an intelligent agent should take actions in a dynamic environment in order to maximize a reward signal ~ Wikipedia

While I barely made it through that sentence, let’s imagine reinforcement learning as training a dog to fetch the ball for you. Every time the doggo fetches the ball, you give the little guy some treats. You’re giving him positive reinforcement, or as we call it incentive, to perform that action. This is basically what we do in RL as well. We give a reward to our intelligent agents based on their actions to get a desired result.

In case of AWS DeepRacer, the agent is a car, and the desired result is for it to complete the track without going off-track, as quickly as possible. This means that our rewards need to account for the speed of the car, the nature of the track, the turns and more.

Now that we have an understanding of what RL is, let’s try to understand the hyperparameters for our model that may have an impact on our end-results.

Batch Size

Models based on Neural Network train in iterations, meaning they update themselves after every round of learning. This hyperparameter gives you control over how much your model learns in every iteration. Keep in mind that all hyperparameters have their benefits and trade-offs. In this case, a larger batch size (say 128 over 64) would mean that the model would have a wider set of experiences to learn through, and generate a steady output, however, over iterations, it would take more memory and time.

In Deepracer context, the batch size can essentially decide on the exploration that your model will remember across various iterations of its training. Larger batch sizes can delay the convergence times but with every iteration, it’ll get your model closer to the optimal path.

Entropy

I heard about this term for the first time in Chemistry, and very simply - it’s a measure of randomness. Think about how much you want your model to explore while training. The possibilities it can figure out to eventually find out an optimal result. In case of your robo-car, it can find different ways to cover a track, for example. taking fast, shorter turns, taking slow, longer turns, etc. and it eventually finds out the best option based on the incentive it gets.

You might want to reduce the entropy with time as the model matures, as you’d figure out it’s closer to the optimal path, you wouldn’t want it to diverge from that.

Discount factor

A value that ranges between 0 and 1, it signifies the importance your model gives to short term gains over the long term rewards. Discounting Factor closer to 1 means that you prefer future success over immediate high rewards on that particular action on the iteration. Whereas a factor closer to 0 means that it’ll prioritise the incentives it just received. In DeepRacer, it’s critical that the car has a long-term foresight so as to ensure it doesn’t land itself is bad positions around curves or turns that can lead to crashes.

Learning rate

This parameter basically controls how quickly your model reaches the point of convergence. However, with higher learning rates, you run the risk of overshooting, wherein you might get to an optimal path quicker and immediately diverge from it in the next iteration. The key, like most other parameters, is balance. You can adjust the learning rate based on observation of the patterns that your model creates while training. In DeepRacer, this can potentially define how quickly your model is able to adapt to changes, eg. sharp turns after a straight road, where your car is initially intending to run at full speed, but then has to slow down and turn 140 degrees.

Number of epochs

Epoch - can be defined as a collective batch of experiences combined by various episodes in a training window. Your complete process can have many different batches, meaning the model has to move on from one set to another. The number of epochs signifies the amount of time your model spends on one such set. This can essentially refine how your model thinks over a certain set of experiences. Longer epochs naturally mean longer training times and compute usage.

Hope this was a good read to cover various Deep Learning jargons and simplify your experience working with neural networks going forward. Thank you for reading:)

The Data Model

As we're working on NoSQL here, there's no real restriction on the structure of data. We can operate with key-value pairs as the attributes for each item in a table. Let's look at these keywords again.

Table - a fairly familiar term, it is essentially a collection of data, in this case, items. It is also the starting point of working with DynamoDB on the console.

Item - an entry in a table. You could consider it a row in an SQL-equivalent database.

Attribute - The datapoints that constitute an item. It could contain item-specific attributes, metadata, or virtually anything that can be associated with an item.

You could think of a JSON array as an equivalent to a table in DynamoDB. I'm sure things will get clearer as we create our own table.

Setting up the database

It's literally a piece of cake to create a new table in DynamoDB from the AWS Console. All you need is a name and a partition key, which is your primary key in this case. This will help you search for items in the table.

I'm creating a table for all the games that I've played, and I will rate them out of 10 :)

You can mess with the table directly from the console, let's try adding a new item to see what it looks like.

My first entry has to be my favourite RPG (role-playing) game - The Witcher 3. I will add a new attribute for rating and it's going to be a solid 9.8 from me :)

Setting up an API

Right, it's now time to write some Python code to do all of this without the GUI ;)

## app.py
from flask import Flask, jsonify, request
import boto3
from boto3.dynamodb.conditions import Key
import uuid  # Import uuid module for generating UUIDs

app = Flask(__name__)

# Initialize DynamoDB client
dynamodb = boto3.resource('dynamodb', region_name='ap-south-1')  # Replace with your region
## Do keep in mind to save your AWS credentials file in the root directory
table = dynamodb.Table('games')  # Replace with your table name

# Route to get all games
@app.route('/games', methods=['GET'])
def get_games():
    try:
        response = table.scan()
        games = response.get('Items', [])
        return jsonify({'games': games}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)

The beauty of Python is that you can setup a full-fledged API in just a few lines of code. This chunk of code is now sufficient for us to access the table and fetch the data from it. We use the scan function to fetch items from the games table.

You can start the app by using python3 app.py

And you can expect a response that looks like this when you curl for the /games endpoint.

Routes for creating and updating an entry

# Route to create a new game
@app.route('/games', methods=['POST'])
def create_game():
    try:
        game_data = request.get_json()
        name = game_data.get('name')
        rating = game_data.get('rating')
        hours = game_data.get('hours', 0)

        # Generate a random UUID for the new game
        id = str(uuid.uuid4())

        if not name or not rating:
            return jsonify({'error': 'Missing required fields'}), 400

        # Store the game in DynamoDB
        table.put_item(Item={'id': id, 'name': name, 'rating': rating, 'hours': hours})

        # Return the created game with the generated UUID
        created_game = {'id': id, 'name': name, 'rating': rating}
        return jsonify({'message': 'Game added successfully', 'game': created_game}), 201
    except Exception as e:
        return jsonify({'error': str(e)}), 500

# Route to update an existing game
@app.route('/games/<int:id>', methods=['PUT'])
def update_game(id):
    try:
        game_data = request.get_json()
        name = game_data.get('name')
        rating = game_data.get('rating')
        hours = game_data.get('hours', 0)

        if not name and not rating:
            return jsonify({'error': 'Nothing to update'}), 400

        update_expression = 'SET '
        expression_attribute_values = {}

        if name:
            update_expression += ' #n = :n,'
            expression_attribute_values[':n'] = name
        if rating:
            update_expression += ' #r = :r,'
            expression_attribute_values[':r'] = rating
        if hours:
            update_expression += ' #h = :h,'
            expression_attribute_values[':h'] = hours

        update_expression = update_expression[:-1]  # remove trailing comma
        response = table.update_item(
            Key={'id': id},
            UpdateExpression=update_expression,
            ExpressionAttributeNames={'#n': 'name', '#r': 'rating', '#h': 'hours'},
            ExpressionAttributeValues=expression_attribute_values,
            ReturnValues='UPDATED_NEW'
        )
        updated_game = response.get('Attributes', {})
        return jsonify(updated_game), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 500

Here, we are using put_item to add an item to the table. For updating a record, we use the function update_item.

If you observe carefully, we are using UpdateExpression where we specify the attributes that we're updating. This allows us to control exactly which attribute gets changed and avoid accidental overwrites.

And to delete the record, you can go with something like this -

response = table.delete_item(
    Key={'id': id},
    ReturnValues='ALL_OLD'  # Optional: returns the item that was deleted
)

Well, there you have it, you just setup a REST API with CRUD Functionality for DynamoDB in a matter of minutes thanks to Python.

Soon enough, I found myself here. However, it took me a while to figure out how powerful it truly can be.

For starters, I was able to hook it up to any Repository within seconds. So I did not have to worry about versioning or sharing it with teammates.

Direct access to GPU instances

You’ll need to get an additional approval to make use of the ml.g-series of instances in SageMaker Notebooks, but it didn’t take longer than a minute for me. And just like that, I have access to a Jupyter notebook with TensorFlow and a GPU.

Integrations with other AWS Services

This is not a Sagemaker feature as much as it is an AWS IAM feature, but when you get hold of the IAM Role that is being used by the Sagemaker Notebook, you can basically open up your Python shell to have access to literally any AWS service via client libraries like boto3.

You can control EC2 instances, invoke Lambda functions, send emails via SES, perform operations on S3 objects and so many other things programmatically through the same Jupyter notebook.

—

So far, it’s been fun watching folks work on Sagemaker Notebooks trying out different ways to automate workflows on AWS using raw Python. Looks like I’ve found my new provider for easy-access Cloud Notebooks.

However, being the curious little geek that I am, I often have the little urge to hop into VSCode and start coding again, whether it's for a mini project, trying out some new tech, preparing for a new article or a talk.

Since my laptop is more used to Netflix than Python now, I don't really feel like installing any dev-tools locally. Here's when Cloud9 comes to my rescue. And here's a few reason why I LOVE IT.

Super Easy to Setup

This isn't even a debate. All it takes is a single click after you fill in a couple of boxes; and you're up and running.

Gives you complete Access

I've used online coding platforms for web-development and Jupyter environments and I've been restricted from using admin commands in the shell and install anything new.

Not with Cloud9 though. It's almost complete control of the environment where I can install whichever packages I want and make use of them.

Integrated with Code Whisperer

This is definitely a great add-on if any Gen-AI code assistant is already a part of your local IDE. I don't use it as extensively but it's a handy tool to have. The results that CodeWhisperer shares are generally very accurate and easy to work with.

Environment Sharing

Much like how LiveShare works in VSCode, you can share the entire setup with your teammates or friends just by creating an IAM User for them.

Do you folks use online code editors or IDEs? Let me know your thoughts on Cloud 9 :)

TLDR: Malicious code with a backdoor was added to one of the core packages of Linux affecting almost all Debian and Redhat distros; was later discovered by a developer at Microsoft because of a 500ms delay in ssh response.

How did we get here?

The two latest releases (as of March 9th 2024) on the xz package apparently contained this malicious code. This code wasn't directly visible on the repo, but was disguised as a part of the tests which in turn modify the function in the liblzma library that uses the xz package. You would get this code upon downloading the specific release tarballs.

This was committed by user JiaT75 on GitHub (also known as Jia Tan; real identities, obviously unknown), who has been a regular maintainer on this project for about 2 years. I'm pretty sure there's way more into this story of how well-crafted this was and what the potential motive behind it could be; but that's not for this article.

How was this found?

Andres Freund, a developer at Microsoft, who is also a maintainer at Postgres thought something was suspicious when he observed a ~500ms delay in his ssh login process (refer to the image below). He was able to analyse further and remember facing similar issues with valgrind in the past with Postgres testing (absolute legend).

I've read a lot about this and I still do not know how liblzma and sshd are related. From what I've understood, sshd internally uses liblzma in some Debian distros (long story short).

I do not know how someone could get to such conclusions with very little detail, gotta respect what Andres has done here. If you want to read more about his analysis, it's available here on OpenWall. Worth the read even though I didn't understand more than 5% of it 🤣

What's the current update?

All major distros that had this xz version in their beta releases have been safely reverted, as confirmed by Debian, Fedora and Arch as of March 29th. From what I read, no stable versions of any distros were affected.

It's fascinating how little we know about the open source software that we use everyday. Things could've gone south very quickly if not for this discovery from Andres. The maintainers were also proactive on getting changes reverted to safety. Stories like these make us realise how little we know; and as tech enthusiasts, I believe it only makes us curious to keep learning.

The New Year is just around the corner and that means that the applications for the AWS Community Builder Program are soon going to open up!

As a Community Builder this year, I'd like to take you through some of my best experiences - becoming a part of the AWS New Voices Cohort.

About AWS New Voices

The New Voices Program is a very new, building idea of gathering potential speakers from the pool of AWS Community Builders and honing their speaking skills under the guidance of experienced speakers from the community who chip in as coaches.

The Overall Setup

Set up in July 2023, we had a total of 4 sessions (once in a week) in which we had to prepare a small talk of 3-4 minutes where we described how we solved a problem using technology (not necessarily related to AWS)

Every new session, a different twist was added to the same topic of discussion to bring in the quality of range to our speaking skills.

Barring the last session, there were no slides. It was all about talking to your audience for a certain period of time, describing how you solved a problem

At the end of the talk, the host along with the Coaches give you actionable feedback that you can work on before you join the next session.

The Power of Acknowledgement

As someone who comes with a history of sheer social anxiety and nervousness on the stage, to be able to stand in front of a crowd and speak today is a blessing.

But it's also still very scary. And definitely not easy for everyone. What helps is the acknowledgement of people listening to you, people telling you that you did a good job and they liked your talk.

This is exactly what I got from this program. At the end of the talk, the host appreciates your effort, talks about the stand-out points in your talk. All the speakers appreciate your work and mention the key highlights where you did well. Everybody jazz hands at you (refer to the cover image) acknowledging the solid work that you did.

I'm not sure about the future of the program, how it's going to be structured in 2024, but I'm exited and super happy to be an AWS New Voices Graduate. Looking forward to more Community Builders joining in Q1 becoming a part of this program as well :)

Thanks for reading, Happy Holidays!

Having said that, we haven't had many contenders for Pandas for quite some time at least in the general space. We do have tools with specific use cases, like Spark for Big Data, for example.

With the increase in data volume, people have been hamstrung by the processing time delays with Pandas. Here's where Polars comes in.

What is Polars?

Polars, on its website calls itself a "Lightning-fast DataFrame library for Rust and Python". Given the amount of popularity Rust had gained recently, I started noticing a lot more references to Polars lately. Without getting too technical, I'll sum up Polars by saying that it's super fast because it's written in Rust, supports lazy evaluation and can leverage multithreading capabilities of a system if available.

There is enough evidence out there proving how much faster it as compared to Pandas, but in this article, let's just try to explore Polars as just another DataFrame library in Python.

Hop In to Jupyter

It's time to warm your hands, grab that cup of coffee and open up your favourite Jupyter environment. I've setup a Jupyter server on Napptive to play around.

We can start by installing the polars library in our environment.

Loading the Dataset

We'll start by loading a simple car-sales dataset.

import polars as pl
df = pl.read_csv("car-sales.csv")
df.head()

Very similar to what we do in pandas, we use the read_csv method; and we see the first five rows printed out when we use df.head()

Next up, if we want a quick statistical summary of the dataset, we can use df.describe() to take a look.

This is obviously only useful for numerical columns.

This has been almost identical to pandas so far, but if I want to take a look at all the columns in the dataset, we use df.columns

Data Manipulation and Filtering

Now that we're a little comfortable, we can start getting our hands a little dirty and start working on a few operations and filters with the dataset.

# For starters, let's apply a filter to our dataset. 
# I want to separately take a look at all Honda cars in our dataset.
# How would we do that?

honda_cars= df.filter(pl.col("Make") == 'Honda' )
honda_cars.head()

Now let's say I'm a little low on budget, I want to take a look at cars that cost 5000$ or less. But for this, I'll have to change that price column a bit, because it's currently a string.

Let's first transform the Price column to a float value. We'll need to take out the $ sign and the commas.

# Remove the dollar sign and the comma from the Price column
df = df.with_columns(
    pl.col("Price").str.replace("\$", "").str.replace(",", "").cast(pl.Float64),
)
df.head()

Now that we have the Prices sorted out, we can apply a filter to show only cost 5000$ or less.

Let's apply this filter.

# Just like we did for Honda, let's apply another filter, 
# this time to see only those cars priced 5000$ or less

budget_cars = df.filter(pl.col("Price") <= 5000.0)
budget_cars

And we get exactly what we wanted.

Now let's pretend like I'm a car geek and I'm very curious about those Odometer values across car manufacturers. I'd want to take a look at the average Odometer values and their average prices across car manufacturing brands.

# Here's where things get a little different from pandas
# Let's write a query to group this data by the car's make, 
# and see their average Odometer values and price.
q = (
    df.lazy()
    .group_by("Make")
    .agg(
        pl.mean("Odometer (KM)").alias("Average Odometer Reading"),
        pl.mean("Price").alias("Average Price")
    )
    )
q.collect()

Now we see a lot of things going here. The first thing we do is call the lazy function; to trigger lazy evaluations for the query, as we discussed as one of the very popular features of Polars.

We're grouping the table by the Make column; and then we use the agg function where we can say that we want the mean of both Odometer and Price columns.

We then use alias to give those a different column name.

And look at that! We've got our result :)

This was a very brief introduction to the Polars module. While I don't believe it's a direct replacement for Pandas yet (long way to go), it has a huge amount of potential and much like any other open source software, it's ever growing. We'll keep exploring this module as I plan to make this a series of threads for Polars.

Stay tuned for more, until then, peace.

Not so long ago, I came across a post from LangChain on the Threads App about how easy it is to create a chat assistant using Llama2.

Here's the tutorial that you can look into, thanks to Anil-matcha who shared it on GitHub.

I've been fascinated by how difficult it generally is to physically host an LLM, but first, let's create an app.

Creating a working environment on Napptive

I sneaked into the documentation a bit and found out that the model can work just on the CPU, but it does better if you also have a GPU.

Since this is all Python, we can create the app on a Jupyter environment as well. The easiest way to create a Jupyter environment on the cloud is by using Napptive.

To learn more about Napptive and an extensive guide on hosting your Jupyter Lab on Napptive, here's one of my old articles you can refer to.

Before you deploy the app though, you'll have to make a couple of changes to the config YAML file. Firstly, expose the port 8501 for streamlit and create a napptive-ingress trait for it. This is because we'll be using Streamlit for the app UI.

Once that's done, you can deploy the app.

Building the App

Once you get into the Jupyter environment, create a new terminal, we have a few things to set up before we get going.

# Install langchain, the llama module and streamlit
pip install langchain llama-cpp-python streamlit
# Download Llama2 model from hugging-face
wget https://huggingface.co/TheBloke/Llama-2-13B-chat-GGML/resolve/main/llama-2-13b-chat.ggmlv3.q4_0.bin

mkdir .streamlit
nano .streamlit/config.toml
## Add this to the config
[theme]
primaryColor="#F63366"
backgroundColor="#111827"
secondaryBackgroundColor="#6B7280"
textColor="#FFFFFF"
font="sans serif"
## Ctrl + S to save the file, Ctrl + X to exit

The UI for this is inspired by the Streamlit ChatBot tutorial which you can find here.

Once the config is setup, create a new file app.py

import streamlit as st

# App title
st.set_page_config(page_title="💬 LLama2 Langchain ChatBot")

# Store LLM generated responses
if "messages" not in st.session_state.keys():
    st.session_state.messages = [{"role": "assistant", "content": "How may I help you?"}]

# Display chat messages
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.write(message["content"])

# User-provided prompt
if prompt := st.chat_input():
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.write(prompt)

Initially, we'll just import streamlit, setup an array to store all chat messages in a streamlit-session and then create the UI for the chat.

from langchain.llms import LlamaCpp
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain import LLMChain, PromptTemplate
from langchain.memory import ConversationBufferWindowMemory

We'll import all the different classes and functions we'll use from Langchain.

callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])

# Make sure the model path is correct for your system!
llm = LlamaCpp(
    model_path="./llama-2-13b-chat.ggmlv3.q4_0.bin",
    input={"temperature": 0.75, "max_length": 2000, "top_p": 1},
    callback_manager=callback_manager,
    verbose=True,
)


# Function for generating LLM response
def generate_response(prompt_input):

    template = """I am a Large Language Model Llama set up on Langchain.
    {history}
    Human: {human_input}
    Assistant:"""

    prompt = PromptTemplate(input_variables=["history", "human_input"], template=template)

    chatbot = LLMChain(
        llm=llm,
        prompt=prompt,
        verbose=True,
        memory=ConversationBufferWindowMemory(k=2),
    )
    return chatbot.predict(human_input=prompt_input)


# Generate a new response if last message is not from assistant
if st.session_state.messages[-1]["role"] != "assistant":
    with st.chat_message("assistant"):
        with st.spinner():
            response = generate_response(prompt) 
            st.write(response)

    message = {"role": "assistant", "content": response}
    st.session_state.messages.append(message)

Further, we initialize the LLM Class with the model that we downloaded, write a function that creates the chain to generate responses and lastly, the UI to showcase those responses.

Refer to the snippet below for the entire code from the file app.py

import streamlit as st
from langchain.llms import LlamaCpp
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain import LLMChain, PromptTemplate
from langchain.memory import ConversationBufferWindowMemory

# App title
st.set_page_config(page_title="💬 LLama2 Langchain ChatBot")

# Store LLM generated responses
if "messages" not in st.session_state.keys():
    st.session_state.messages = [{"role": "assistant", "content": "How may I help you?"}]

# Display chat messages
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.write(message["content"])

# User-provided prompt
if prompt := st.chat_input():
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.write(prompt)

callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])

# Make sure the model path is correct for your system!
llm = LlamaCpp(
    model_path="./llama-2-13b-chat.ggmlv3.q4_0.bin",
    input={"temperature": 0.75, "max_length": 2000, "top_p": 1},
    callback_manager=callback_manager,
    verbose=True,
)


# Function for generating LLM response
def generate_response(prompt_input):

    template = """I am a Large Language Model Llama set up on Langchain.
    {history}
    Human: {human_input}
    Assistant:"""

    prompt = PromptTemplate(input_variables=["history", "human_input"], template=template)

    chatbot = LLMChain(
        llm=llm,
        prompt=prompt,
        verbose=True,
        memory=ConversationBufferWindowMemory(k=2),
    )
    return chatbot.predict(human_input=prompt_input)


# Generate a new response if last message is not from assistant
if st.session_state.messages[-1]["role"] != "assistant":
    with st.chat_message("assistant"):
        with st.spinner():
            response = generate_response(prompt) 
            st.write(response)

    message = {"role": "assistant", "content": response}
    st.session_state.messages.append(message)

Running the App

To run this file, create a new Terminal window and run the following command -

streamlit run app.py

If the service is up and running, you'll see a similar message in the shell from Streamlit.

You can check the app following the link in the streamlit endpoint on the Napptive Console.

While you enter the prompts on Chat, you can also check out what it does on the Terminal.

Final Results

Here's a demo of what the app looks like.

The app runs fine, but I've come across a few issues, for starters it's very slow (understandably because it's on CPU) and secondly, sometimes it loops itself where after finishing the response it automatically creates a new question and starts answering it.

What could've been better?

I didn't spend too much time on the UI, so you can see that the chatbot just dumps the response instead of streaming it word-by-word as you would see on other bots like ChatGPT.

That's it for this article, I hope you liked it, stay tuned on this series because I'm pretty sure there's a lot more to come. In the next article, we'll try something similar with the help of AWS Sagemaker :)

As always, thanks for reading, keep spreading your love, Cheers! 🥂

The most common problem I've seen with students who are pursuing tech-related courses is their lack of awareness vis-à-vis the latest trends in tech, preparation for placements and tech-related activities on their campus.

The teaching faculty has their priority set (and rightly so) on covering their respective syllabus and related academia. The easiest way for one to get any kind of awareness is by communicating with their seniors. But it ain't as easy as it sounds, is it?

Now, let me get this straight. Talking to seniors isn't the only way to get awareness and insights. Heck, I'm pretty sure they haven't sorted things out for themselves. But they can help you with their experiences, things that they found out late, the mistakes that they made and more.

But as a senior, I feel that we have a responsibility to contribute to the community of students in our college. Here's how I suggest you can do that.

Foster Awareness of College Opportunities

Right from picking the best dishes in the canteen to identifying the best professors for specific subjects, or professors who let you go easy on attendance, I feel that you have a better idea than the poor kids coming freshly into your departments.

Just having a word with the juniors, and making them aware of these little opportunities on campus is a great contribution to the community in itself, and besides that, it adds a new friend to your tally. I've had chats with an endless number of people about the companies that come on campus when the placement drives happen and how they can approach them.

Talk about community programs, talk about internships, I'm pretty sure you can talk about your college the entire day, and now you have a set of ears to listen to you as well :)

Cultivating a Tech-Driven Campus Culture

I hear a lot about people not getting opportunities in Tier-3 institutes and/or universities. It's going to take some effort to change that. I feel that a few right steps from seniors can be the ideal ignition to this process.

Start by organizing tech events that allow people to network with each other and facilitate tech-related discussions. The more you talk about tech, the more it will be brought up on different occasions.

As people get more and more aware of the benefits of building a dev profile and solving DSA problems, you'll start seeing a shift in the mindset of people.

Raising the Skill Bar

I briefly discussed developing a solid culture in and around the college, but this is arguably the biggest challenge in any institute, to improve the overall skillsets of individuals coming in year after year.

It's not about those one or two individuals who get amazing offers from big companies, but what the majority of people are trying to achieve. That is when a college truly experiences a culture shift.

I was using HTML/CSS/PHP/MySQL and React/MongoDB as references not because one is better than another, but because you start with HTML and CSS as a beginner, and you gradually pick frameworks to work with. The more experienced you get, the better the chances that you are working on a framework.

Conducting workshops and seminars that explain the real-life use cases not just for web frameworks but any technical specialty, in general, will facilitate this kind of growth. Organizing Hackathons is another solid idea.

Here's how I look at it. As a senior, especially during the final few months in college, I felt that I should try to create an impact on the community around me. These people in college, they are my people. The ones who are still there and those that will join every year. These are just a few ways through which I was able to give back to this little and wonderful community. Please feel free to share your ideas in the comments too 😊

However, if you're someone like me who does most of the work on the Cloud, or to be specific, remote environments, this may not be the right choice for you.

Something that I discovered pretty late is that Docker, for quite some time, has had a super fast solution to install Docker Engine in Linux environments.

If you check the website https://get.docker.com, you will find out that Docker maintains a script to install Docker Engine on Linux.

As they mentioned, this method is not intended for production environments, which I assume anyway will be working with a specific Docker version.

The best part about this script is that you need absolutely no package managers to work with.

Installing Docker using the Script

# Download the script
curl -fsSL https://get.docker.com -o install-docker.sh

# Run the script as it tries to figure out the type of Linux
# distribution it's dealing with and installs the latest CLI and Engine versions
sudo sh install-docker.sh

Simply running these two commands will install the latest version of the Docker Engine, its CLI and a few other tools/plugins like Compose, Buildx, etc.

Run Docker without Root access

Now, if you run any docker command after installing, you'll probably come across a similar error. The quick solution to this is to run the same commands with sudo, but it has been fairly annoying to me. But there's also a quick 1-command fix to this.

sudo usermod -aG docker <USERNAME>
sudo reboot

The flags a and G in the command are to add the user to a group, and just by running the command and rebooting your system, you can run docker commands without root access. Even though this requires one-time super-user access, I feel that it's definitely time-saving.

Thanks for reading, I hope you have a good day ahead :)

Supabase is a BaaS (Backend-as-a-service) I've been using for my full-stack projects for almost 2 years. It's an amazing service that is open source, runs on top of Postgres and brings cool features like auth (even third-party auth support for a zillion providers), storage, realtime and much more.

Why self-host Supabase?

You can totally work with Supabase on the Cloud, as easy as it gets. But if you are on its Free Tier, you have limited access to some of the features of the application. And that's any service, not just Supabase.

I feel that is why it's great to have the freedom to self-host these service-based applications because you get full control of how they run.

What this does is that it gives you control over the infrastructure on top of which it runs, so you can take care of the scaling process as and when needed.

Or you don't want to see Ant's emails every week. Yeah, that's about it.

In this article, I'm going to cover how we can quickly get Supabase up and running self-hosted on an AWS EC2 Instance. Let's get going!

The Supabase Documentation already mentions an article on how you can self-host it using Docker. We're going to follow it as well :)

Before getting started, let's take a look at the things we are going to need:

• An AWS Account

• Preferably a few AWS credits, you may incur a bill

Let's start by creating our EC2 instance on AWS!

Setting up the EC2 Instance

When you're launching a new EC2 instance, make sure you select the Ubuntu AMI, any instance type that has more than 4GB RAM, and preferably 20GB of storage.

Another thing is that you need to ensure you have all TCP ports and IP addresses open for inbound connections in your Security Group (not recommended in production, of course)

Once you've launched the instance, you can connect to it on the browser using EC2 Instance Connect, or if you've got a thing for fancy terminals like me, use SSH along with your key-pair to use your good old Terminal. Keep in mind, you use the Public IPv4 address along with the username ubuntu to connect.

Installing all dependencies

Before we start installing dependencies, we're going to update our package list by running sudo apt-get update -y

After that, we're going to install Docker.

Installing Docker

curl -fsSL get.docker.com -o install-docker.sh
# This scripts installs the latest version of Docker Engine in your Linux machine
sudo sh install-docker.sh

## If you want to use Docker aommands without sudo or admin privileges
sudo usermod -aG docker ubuntu
## After running this command, reboot the instance for it to reflect

We'll install Docker from its install-docker script on the official Docker website. You can continue using Docker as a super user OR just update the local user group and reboot your EC2 instance. It doesn't take long.

Next up, we're going to set up Supabase!

Setting up Supabase

## Following from their documentation
# Clone their repository
git clone --depth 1 https://github.com/supabase/supabase

# Go to the docker folder
cd supabase/docker

# Copy the fake env variables
cp .env.example .env

As mentioned in their documentation, all we need to do is clone the Supabase repository, copy and change the environment variables and get going!

As good practice, NEVER work with the default environment variables.

nano .env
## Once you've made the changes, Ctrl+S to save and Ctrl+X 
## to quit Nano and return to the shell.

## Then run docker compose up command to start the server
## This spins up 
docker compose up

You can use Nano to edit the .env file and make changes to your keys. You can follow the documentation to generate new keys and secrets. Once you've done that, you can run docker compose up to get things up and running!

Check out The Studio

At this point, you can check out if the Supabase Studio runs on http://<YOUR_PUBLIC_IP>:3000/projects

If you want to stop the service, you can do so by pressing Ctrl+C or running docker compose down if you're on a different shell window.

Recommended Cleanup

Make sure you terminate your EC2 instance after you've stopped using it, or you may have a few unpleasant AWS billing-related emails coming your way.

Are the AWS billing emails worse than Ant shutting down your Supabase projects every week? Debatable. We can talk about it.

That's it for this article, folks. Hope you liked it, I'll see you in the next one :)

Writer's Note: I've written this thread in the context of career and life (in India), so you can expect less technical advice.

Performing Under Pressure

As a professional, especially in the tech industry, you'll find yourself working most days under the pressure of deadlines, client expectations and many more.

In Engineering, the pressure becomes second nature. You face deadlines for assignments, and journals every other day. At a certain point, I've had more than 10 submissions to cover in a matter of 3 days, which is insane. Yet, I somehow managed to do it.

The key here is to learn how to manage your time and bring the best results even when you're under the pump. This is a skill set that is immensely valued in the work environment.

Upskill through hard work

You open up Instagram and all you see is motivational reels and podcasts talking about rules and shortcuts so that you can achieve everything in the next 48 hours. Not how it works, sadly. Good things take time.

What I mean by upskilling is to become technically sound. Technology is changing by the minute. Faster than ever these days thanks to AI and what it brings. If you're not up-to-date with what's latest, it'll become challenging for you to get jobs in the long run.

Start with the basics. Pick your favorite language, and master a framework and a tech stack that you can use in your side projects and hackathons.

Practice solving problems on Leetcode, Hackerrank or other platforms. It is a critical skill to land an interview in most tech firms.

Explore different domains, Web and App Development, Data Science, DevOps, Cybersecurity and many more. See what you like the most and gain expertise in that field. Become un-replaceable.

Do not rely on your college

Most universities (in India) have outdated syllabi which cover barely 10-15% (being optimistic) of what's actually used in the industry. The theory is important and generally well-covered. Practical knowledge is what we mostly fall behind in, and that's where self-learning becomes critical. You need to develop the ability to learn by yourself, something that you'll keep using in your professional life.

If you're in a Tier 3 institute in India, your on-campus placement statistics may not impress you as much. In that case, you'll have to explore opportunities off-campus, for which you'll need a good set of skills and a solid network.

You can always look around for referrals. Having a good network on Twitter or LinkedIn always helps.

Experience Responsibility

Arguably the most important thing that I learned in these 4 years.

The respect that you earn and the value that your work creates in an organization are heavily reliant on the levels of responsibility you're able to take as a professional. It's as simple as people describing you as - "They know what they're doing, they get the job done".

The only way you can learn how to manage responsibility is by doing it at relatively easier levels in your college life. Volunteer to organize different technical and non-technical activities in college, it could be a part of fests, cultural programs or virtually anything. This kind of leadership experience helps you build confidence in yourself. Not only does it help you work in teams, but it also makes you a better team manager.

As we walk into our colleges, we are mostly naive 17-year-old kids who have no idea what adult life looks like. We're in our own little world having fun because in most cases, there are people who take care of us in almost all aspects of life. And suddenly, by the time we're done with Engineering, we're 22 and now we've to take care of everything on our own.

Aside from all the leadership skills, this kind of experience also opens you up to different perspectives and makes you a more mature human being, which is critical not just at work, but also in life.

Build Lifelong Connections

When I came into Engineering, I was an introverted kid who knew no one, didn't speak to anyone and just went on with his business. I used to think this is how I was always going to be.

What you see in this picture are the 7 gems of my life who I met in my Engineering college. I can't say enough that I've been insanely lucky to meet them and be in a group of such nice human beings.

As I've mentioned several times before, life becomes very different after college, so please make sure you make the most out of these 4 years in every way possible.

Give back to the Community

Everything that I know in tech today, I owe to my teachers, online instructors, easy-to-read documentation and the creators of countless YouTube videos and courses out there. I have to mention the great man Brad Traversy. He's the first tech YouTuber I started watching when I worked on my first web-development framework - Laravel. I think he is a legend, especially after getting to know his story and in my mind, he's the best developer out there.

As much as I call it self-learning, it is all possible because of the content that is available today. Most developers of yesteryear would agree how difficult it used to be to work with things when you got stuck working with an old codebase.

I have a separate thread coming up later this year about this aspect, but you can start by having coffee chats with your juniors in college, talking about technologies with them, helping them in taking better decisions, telling them to avoid mistakes you made and more.

That must've been a long read, and I'm glad you came here. Thank you for giving me a little bit of your time, I hope your coffee was nice and I hope you have an amazing day ahead.

In this thread, I want to share my story and leave you with 3 strategies to become a good public speaker.

My story

I used to be a guy who was afraid of the stage right from school. Even during the days of my junior college (11th grade), my feet used to shiver when I was on stage. My nervousness was at its peak. And it was pretty much the same through the first half of Engineering.

My transition from a guy who could barely speak in public to a proper public speaker who now talks live on stage and takes online sessions and workshops happened in the last 12 months.

The key is self-confidence. I know for a fact that it is challenging to improve your confidence. It takes time. The best way to boost your confidence is by doing things. Build that application, create that new design, publish that blog or upload that new video you worked on. When there is a sense of achievement, it creates self-belief within you, so when you talk about it, you back your words with actions, essentially practicing what you preach.

If you're starting out or even trying to improve as a speaker, here are some things I'd recommend you to do.

Keep it Simple and Natural

First of all, the moment you hop in on stage, take a deep breath. I mean it. Make yourself comfortable. Taking deep breaths generally kicks down the anxiety and ensures that you're not overwhelmed by the occasion.

If you're starting out, speak in the language you're most comfortable with. It could be your native tongue. My native tongue is Tamil, but I'm most comfortable speaking in Hindi and English and generally, I keep it as a mix of the two depending on my audience.

The best conversations happen when they are authentic. I'd highly recommend that you talk about YOUR experiences because they are the most valuable from any speaking event.

A lot of people talk about voice modulation, but I suggest that you talk in your normal voice at the beginning, you'll discover these things as you progress.

Ask questions to the audience

Most people in the audience refrain from speaking, but there are always a few people who will add immense value to the conversation. So it's best to have their opinions on board.

When you're sharing an experience or an idea, you can ask the audience for similar experiences and thoughts. If the audience does not seem to interact, you can switch to "Yes/No" questions and questions that only require them to raise their hands.

I mention this because this period of getting an answer from the audience buys you some extra time to breathe, recollect your thoughts and probably introduce more ideas in the session.

Narrate your Stories

I've said this before. Your experiences are the most valuable assets from your talks. Especially as developers, when we talk about languages, frameworks and tools, it's almost certain that there is written and video documentation for the same thing freely available online.

You can make your sessions unique by talking about your experiences, and your stories because they are specific to you. This might also end up inspiring individuals from the audience to bring their perspectives to the table. It could be anything, an interesting aspect that maybe not a lot of people discovered, a unique approach to something, etc.

I've observed that people love listening to stories and when you're talking to people of your age group, there's a lot that they can relate to as well.

As you keep speaking, you'll become more and more confident about your skills. It will take time, but I assure you that you'll get there one day :)

To find patterns and anomalies that can point to fraud, we can make use of machine learning and its capabilities to provide conclusive evidence of fraudulent activities.

Observing the data

Our dataset contains insurance claim logs from an automobile insurance company in the United States. We have customer information, policy identifiers, premium payment information, and other payment-related data. But most importantly, we have information about the incident, including the date, type of collision (not applicable if the car was stolen), time of day, witnesses, injuries, and other details across seven states. There are initially 1000 rows and 41 columns in our dataset.

Our target column is: fraud_reported

We can sense that it's a classification problem.

Now ideally, one could just dump this dataset into MindsDB, train a model and get done with the job. But it probably isn't the best approach.

Okay, I tried it 😂 and was able to get 88.5% accuracy, which isn't half bad for a classification model given the number of features we were dealing with, but we can certainly get more.

Let's take a step back and open this up on a Jupyter Notebook!

Data Preprocessing

I didn't do too much work here, just the usual stuff, removing irrelevant rows, data transformation, etc.

df = pd.read_csv(path)
df.shape 
#! (1000,40)

df.policy_number.nunique() 
#! 1000

## Removing a useless column (never knew why it was there in the first place)
df = df.drop(['_c39'],axis=1)

## Convert the policy_bind_date column to a datetime format
df['policy_bind_date'] = pd.to_datetime(df['policy_bind_date'])

## Extract the year, month, and day from the policy_bind_date column
df['policy_bind_year'] = df['policy_bind_date'].dt.year
df['policy_bind_month'] = df['policy_bind_date'].dt.month
df['policy_bind_day'] = df['policy_bind_date'].dt.day

## Drop the original policy_bind_date column
df = df.drop('policy_bind_date', axis=1)

## Replace question marks with more sensible information
df['collision_type']=df['collision_type'].replace("?","Not Applicable")
df['police_report_available']=df['police_report_available'].replace("?","Unknown")

# Remove irrelevant columns
df=df.drop(['incident_date'],axis=1)

After this, I did a little bit of feature engineering to transform categorical data into numerical.

# A simple form of OneHot Encoding to get numerical data out of categorical
df=pd.get_dummies(df,columns=['policy_csl', 'insured_education_level','insured_occupation', 'insured_hobbies', 'insured_relationship', 'incident_type', 'collision_type', 'incident_severity', 'incident_state', 'insured_zip', 'authorities_contacted', 'auto_make', 'auto_model', 'policy_state', 'insured_sex','capital-loss', 'capital-gains', 'incident_city', 'incident_location', 'property_damage', 'police_report_available'], drop_first=True)

After this, we come across an interesting metric:

As you'd expect, the number of fraud cases is way lesser than the non-fraud ones.

This begs the question, is it safe to drop them as-is to a machine learning model?

Applying SMOTE

Most machine learning (prediction) models work ideally when the number of samples in each class is almost equal. These algorithms are made to minimize errors and maximize accuracy.

When there is a significant imbalance of class, it would give significantly less priority to the minority class while making the prediction.

Even in our dataset, if you'd predict every row as non-fraud, you'd still be 75.3% accurate, which is still a good score, but it ain't a machine learning model.

While there are different resampling techniques to fix this issue, I decided to go with SMOTE, which stands for "Synthetic Minority Oversampling Technique".

What is SMOTE?

This technique is used to generate synthetic data for minority classes, in our case, the fraud class.

It randomly picks a point from the minority class and calculates the k-nearest neighbours to that point. These points are added between the chosen point and the neighbours.

Before applying SMOTE, I'm going to use a RandomForestClassifier to generate the best features from our dataset. These are features that contribute the most to the "fraud_reported" result.

### Generating best features

# Load data and split into features (X) and target (y)
X = df.drop('fraud_reported', axis=1)

# Create random forest classifier object
rfc = RandomForestClassifier(n_estimators=300)

# Train model
rfc.fit(x, y)

# Get feature importances
importances = rfc.feature_importances_

# Sort feature importances in descending order
indices = np.argsort(importances)[::-1]

top_500_indices = indices[:500]
top_500_features = X.columns[top_500_indices]

# Update X to include only top 500 features
X = X[top_500_features]

Finally, I'll apply fit this in a SMOTE class instance.

%pip install imblearn
from imblearn.over_sampling import SMOTE

x_upsample, y_upsample  = SMOTE(random_state=42).fit_resample(x, y)

Now that we're done with the preprocessing and feature engineering, I'm going to dump this dataset into a CSV file.

new_df = pd.concat([x_upsample, y_upsample], axis=1)

# Save the merged dataframe to a CSV file
new_df.to_csv('updated_fraud_insurance_claims_dataset.csv', index=False)

Setting up MindsDB

Instead of using MindsDB on the free provided cloud instance, I took the fancy route to self-host it on an AWS EC2 instance. I liked it so much that I made a video about it.

Creating a Model on MindsDB

I simply used their UI to upload the dataset I just generated.

CREATE MODEL mindsdb.insurance_claims_fraud_predictor
FROM files
    (SELECT * from fraud_dataset)
PREDICT fraud_reported;

I then ran this simple SQL query to create a model on MindsDB.

Making Predictions on MindsDB

As you can see, we have a much better accuracy than before. Our accuracy is now 94%.

SELECT t.policy_number,t.fraud_reported AS EXPECTED_TARGET, m.fraud_reported AS PREDICTED_FRAUD_REPORTED, m.fraud_reported_explain
FROM files.fraud_dataset AS t
JOIN mindsdb.insurance_fraudulent_claims_predictor AS m
LIMIT 10;

After this, I just ran some batch predictions on the same data using this query.

As you'd expect, we get the right result 9 out of 10 times.

It was fun working on Machine Learning after a long time, thanks to this hackathon from MindsDB and Hashnode. It was fun working with it, I even tried to make a tiny contribution to their documentation.

Looking forward to more of these competitions. Until next time, cheers!

About DevBytes

Much to the delight of developers who can't stay on the same screen for more than 10 seconds, DevBytes is a Tech News Application that brings you the latest news and updates in the form of flash-cards along with bells and whistles like hiring updates, crypto-watch and more in a small bundle of 6 MB.

Rated 4.6 with more than 100K downloads on the Google Play Store, DevBytes certainly has earned its hype for an app that is famous for "Latest Programming & tech news in 64 words".

First Impressions

The onboarding procedure is rather simple, the app tells you to pick an alter-ego to get an idea of your interests and then also lets you manually pick another few topics to curate your feed. You can also optionally sign in using Google or Twitter.

Spoiler alert: I had to choose Sheldon Cooper.

Here are some of the app's features that caught my eye instantly.

The Daily Digest

The Daily Digest contains a set of hand-picked news articles with the most important news of the day. This list is also maintained keeping your interested topics in mind.

What you'll also notice is that all of these articles are less than 64 words.

You hear that? Yeah, that's your attention span saying thanks.

My favourite bit is that it also sometimes contains memes like this one.

The Feed

We are in an era of infinite content and we need some amount of curation to get the best out of it. The Feed gives you a choice to maintain a separate category of articles that are purely from your selected interests. As the app suggests, "Your content, your choice".

Coding Snippets

Another useful thing about this app is that it also supports code snippets that come along with the articles in small cards. You can also copy this code to the clipboard and share it with your friends if you find it interesting!

Crypto Watch and Hiring News

The app also provides a separate tab to monitor your favourite Cryptocurrencies in real-time. Quite a nifty feature to have.

And while you're scrolling through the news, you will also come across hiring updates for various tech roles in different companies.

Swiping the other way

Keeping the best for the last, this is one such feature that you'll instantly notice as you launch the application where you're told to swipe down instead of swiping up. We're traditionally almost maintained a muscle memory of swiping up through content in different social media apps.

I feel that this in a way breaks that habit of swiping up and going back to those apps just for scrolling needlessly. Not to mention that scrolling on this app will make you learn more as well.

With its user-friendly interface, daily digest, custom feed, code snippets and other features like hiring news and crypto-watch, DevBytes is the perfect app for those who want to stay informed while on the go. If you're interested in trying out DevBytes for yourself, you can download it for free from the Google Play Store by clicking on this link.

You can also get DevBytes on the Google Chrome browser via their Web Extension.

👋About Me

Hi, my name is Sreekesh and I'm a Software Developer and a Content Writer. I've been learning and working with full-stack web development for almost 3 years. I'm a final year undergrad student from the University of Mumbai, India.

In this article, I'll try to change your mindset of approaching errors and problems in your code and working your way towards solutions in a hassle-free manner. I've participated in numerous hackathons and I've explored different ways to debug errors especially when it's a race against time.

🛣️The Approach

We're gonna follow a series of simple steps to find a solution to the error we're facing.

Understanding the Error

One of the silliest mistakes people make is blindly copying the error and putting it on the browser or ChatGPT. The key here is to first understand which part of your code is producing the error, what your code was intended to do and which end of the workflow is causing the issue.

Backtracking to the error

When it isn't clear which part of the workflow is causing the issue, you can walk through the code in reverse, i.e. from the final line all the way through to the start. Feel free to make use of console.log or other print statements in your language to log outputs at different stages of your program. This will provide you clarity about the exact lines that are giving you trouble.

Exception Handling

Utilize try-catch statements to gain a comprehensive grasp of your program's workflow and guarantee a crystal-clear understanding of potential code-breaking points. By implementing this strategy, you increase code readability and facilitate comprehension for others.

Making good use of Google Search

Famously known as Google-ing, the idea is to be efficient at finding things out of Google Search. All you have to do is put your error out on google search and take a look at the results. The chances are, you'll find yourself in a StackOverflow thread, an old GitHub Repository Issue Discussion or literally on the documentation website.

Google-ing doesn't make you any less of a developer. The best developers I know are the ones that use Google the most. Much like any other tools like StackOverflow or ChatGPT, which is where we are heading.

Reading the Documentation

You'll find most solutions related to syntax errors, typos in function names, etc. in the documentation. Sometimes, you miss out on an argument, or there's a typo in the function name and sometimes functions and objects are deprecated by libraries and replaced by other utilities. When you grow as a developer, you'll find yourself interacting more with the documentation and less hobbling around search results.

Taking help from StackOverflow and Chat GPT

StackOverflow is still the holy place where most of your errors will be solved. The knowledge base of that website purely out of support from community members is insanely huge. However, we now have friends from OpenAI that make use of websites like StackOverflow and bring results to us even quicker.

Given how fast ChatGPT is in finding things out, it is a handy tool for debugging. In fact, in a lot of cases, ChatGPT alone could fix your problems. However, I wouldn't recommend this for now, because it doesn't seem to manage versions (it sometimes shares dated/deprecated code) as well as one would expect.

Taking help from Discord Communities

Discord has to be my favourite community platform. Most frameworks and tools that I use (like Next.js, Supabase, Flutter and more) have already set up their Discord servers where people talk about the software, and its issues, there are spaces where people can share their errors and more. This is why I feel that you should explore different communities on Discord because they can certainly help you in the debugging process.

Here's Supabase's Discord server for instance. There's a forum channel set up for doubts and issues. You'll have a similar experience with your frameworks as well, the open-source community is very friendly and amazing when it comes to supporting at this level.

🚩Debugging Don'ts

Errors are, in a way, your friends. Because every new error teaches you something, even though you might find them annoying. While you are on the warpath to solve that annoying error, I want you to steer clear of these things that can potentially destroy your learning process.

❌ Ignoring Error Messages

❌ Copy-paste results from StackOverflow or ChatGPT without a second thought.

❌ Deleting Code without clarity.

❌ Not sleeping until you fix the error.

❌ Not documenting the lessons you've learned.

Final Advice

The difference between a Junior and a Senior Developer is the number of errors they've come across.

Enjoy getting new errors. As I mentioned, they are a part of the process and inevitable. Going through this process of debugging is very rewarding and gives you a sense of achievement at the end of the day.

I hope I was able to provide practical and effective steps for debugging errors in various programming languages and frameworks. I hope that this guide will help developers approach errors with a positive outlook and that they will find the solutions they need to create effective and efficient code. Embrace the process, keep learning, and keep growing!

Are you confused about the things to mention while introducing yourself in an interview, like you holding the record for the longest sleep duration? Or do you just want to say Hi on Twitter because your friend Mike got famous because he tweeted about the advantages of the span tag in HTML?

Then say Hi to IntroAI - a website powered by the OpenAI API that can generate introductions for you in different tones (like funny, or professional) and based on your specified context (in a technical interview, or for a LinkedIn About section).

The Inspiration

I was scrolling through Twitter one fine morning and I came across this tweet.

I watched that entire video and saw what that guy did with the OpenAI API and Vercel Edge functions, and it was simply amazing. I think you should take a look at it as well. He made the website twitterbio.com which generates Twitter bios based on context with the help of the OpenAI API.

This inspired me to think of other ideas and the possibilities that this tech opened up.

The Thought Process

I'm a Full Stack Developer and I've been working with Next.js and TailwindCSS for more than a year, which is why I was easily able to understand what Hassan was doing in the video. The tricky part was to understand the part where he wrote a function to create an OpenAIStream which he then calls from the Edge function.

I've always been fascinated by the capabilities of AI and tools like ChatGPT are amazing utilities for our day-to-day activities. There had to be more use cases for the API, especially in the context of text generation.

Sitting on the train, I had this lightbulb moment, which took me back to a seminar I had taken for my juniors just a day before, for preparing for their placement season, viz. building a profile, preparing for interviews, etc.

Introductions! And you won't believe how many people have issues with making one for themselves! This thought was an absolute game-changer. It was the ideal add-on to the existing project that was out there. All that was left was to launch VSCode.

The Result

Want to see how AI introduces you? Check it out here!

You can also get the source code on my GitHub repository.

It's fascinating how such a simple idea could result in such a nice-looking product. I'm glad I was able to build this.

Thanks for reading, let me know your thoughts about the project. I'll see you at the next one. Until then, take care :)

To understand what went behind all the events that transpired in 2022, it is important to know what happened in 2021. Let's take a short recap of 2021 before we take a look at this year.

2021 Recap

I'll try to keep this as short as I can. 2021 was tough for me, physically and mentally. But it taught me that I've got some incredible strength of perseverance and commitment within me.

It was another year that was taken away by the pandemic, everything was confined to the 4 walls of my room. But that didn't stop me. I was determined to follow the process despite not seeing results at times. I made sure that 2021 was THE MOST productive year of my life.

I found this screenshot from my old recap tweet and you possibly get an idea of how many different technologies I was able to learn because I was at home all day, most of which I learned in the second half of the year.

By the end of 2021, I was confident, technically sound, immensely sleep deprived and breathing caffeine in and out.

Realizing what I had been missing in the last year, I decided to put a conscious effort towards sleeping well and maintaining my fitness in 2022. I also decided to build connections and network with a lot of people this year. We'll see how that goes :)

Taking my First Online Coding Workshop

Very early in January this year, thanks to the Quest IT Cell, I was able to conduct my first-ever coding workshop where I talked about TailwindCSS and how easy it is to create UI with it. I was joined by a small group of students who were very new to web development but showed a lot of interest.

After talking about the different use cases of Tailwind, we started coding and ended up creating a Resume Website, styling it with TailwindCSS and deploying it to Netlify.

It was a great feeling, especially doing this for the first time. Got some really good feedback, and I was very motivated to keep doing more of these.

Crossing 100 WPM

I crossed 100WPM for the first time on 15th May 2022. Something quite normal for a lot of tech nerds that I know, but this was a huge achievement for me, because of one reason.

I've been typing on the same old Microsoft Keyboard right from 2009 all the way through to 2020. I did not have any professional training in keyboard typing, which is why it is very unconventional.

I do not use more than 7 fingers while typing (ideally, you'd use all 10)

Just muscle memory took me to 84-85 WPM. But it took 2 weeks of consistent practice to take me past three figures.

Solving 250 Problems on Leetcode

I'm not a fan of how one's performance in solving a complex Leetcode/CodeChef question is directly mapped to their skill level (because that's how most people land interviews and eventually, jobs). This is just my opinion, I'm sure a lot of you might disagree, and I can completely understand that.

Regardless, I needed a job too, which meant that I needed to step my game up in DSA and Problem Solving. From being nowhere at the end of 2021, I worked consistently for 3-4 months and solved a variety of easy and medium problems. I also participated in multiple Leetcode weekly contests.

I have to admit, it is a good use of logic, common sense and an understanding of data structures when you solve these kinds of problems. The satisfaction of solving a problem after wrapping your brains around it for a good half an hour is also unmatched!

WINNING A HACKATHON

In June, my team was adjudged the Winner of Code For Good 2022, a tech-for-social-good hackathon organized by J.P. Morgan Chase & Co. This hackathon was also the final stage of their Software Engineer recruiting process.

We were a team of 8 initially, but due to some circumstances, we were left to a count of just 4 teammates by the time the problem statements were shared. The events that followed in the next 24 hours are no short of an absolute miracle. Staying up all night, we managed to present a complete solution to the judges.

The developing experience, the energy, the interactions with mentors and eventually the reactions from the judging panels after listening to our presentation, oh boy, I was floating on air at one point!

If you're interested to know more about this story, take a look at this article where I described my experience in detail.

Taking a Break

After all the drama that transpired in the hackathon in June, I decided to take a small break from all the hustle. It had been a very productive yet very taxing period of six months for me. I did not entirely disconnect myself from everything, but I made sure I got my life back on track and fixed my sleep schedule, diet, etc. A little bit of greenery helped as well.

A Job Offer from JP Morgan Chase & Co.

A few days after college resumed, I got to know that I was one of the students to be offered a Software Engineer Full-Time Role at J.P. Morgan Chase & Co.

This, being my first job offer, was a huge moment for my parents. I cannot describe their happiness in words, let alone mine. It felt like all of those extra hours I put into upskilling myself paid off. I'm excited to join the company in 2023.

If you're interested in the recruitment process, please take a look at this article.

Taking an in-person DevOps Session

Once I was back into business, I took a DevOps fundamentals session for my juniors in college. I talked about the understanding of DevOps technologies, Agile Terminologies, CI/CD Pipelines, etc.

It was a very different experience because I was doing this for the first time in person. The butterflies you feel initially, and then gradually breathing into the session, was a surreal feeling.

Taking the big stage for the first time

Our college has this auditorium, a quite large seminar hall where a lot of sessions and talks are conducted. I've always had this fascination with speaking at the helm but never had the courage to do so.

All of that was about to change. I was invited to deliver a talk about preparing for campus placements in coordination with a friend and a college alumnus.

It was the first time I had ever taken hold of the microphone in front of a 100+ audience. Suddenly, once I started speaking, there was no nervousness. I was able to talk well and convey my ideas. The response from the audience was also great.

To my further surprise, the feedback I received from the faculty was amazing.

Public speaking hasn't been one of my strengths. The last time I took the stage before this, well, that has never happened. I consider this to be one of my biggest achievements, to be able to deliver in front of a crowd.

Runner Up in Hashnode 4Articles4Weeks

I found myself jumping on my couch when I saw that our Community Manager had mentioned me in her new post.

If you asked me a year before, I wouldn't have even imagined an idea of a "Write-a-thon", forget winning in one.

This competition really tested my brainstorming skills and consistency. If not for this contest, I do not think I would have come up with the Improving CSS using Instagram idea. And guess what, the article did so well. It was liked by everyone.

To be able to make it to the runners-up is a huge acknowledgement of the amount of effort I have put into Content Writing.

Hashnode has had a huge role to play in my development as a Content Writer in the last 14 months.

Creating a Tech Community

During my interactions with my juniors, I felt that I would make a good mentor, despite being a college student. It felt a little unfortunate that my reach was restricted to a small set of students.

In late November, I decided to create my Community on Discord. It's called One Byte Social.

The idea behind this community is to provide everyone in tech with an environment that promotes growth and skill enhancement, where they can network with other people and share their work. I'm glad to share that it now has more than 200 members.

I look forward to sharing resources, hosting online sessions and providing mentorship to newcomers in tech in the future. We recently hosted a Twitter Space and also interacted via a Discord call.

If this sounds interesting to you, feel free to join us here.

What I learned from 2022

Life has taught me a lot this year. I'd like to share some of those learnings with you, hoping that it helps.

• Motivation is temporary. Discipline has to take over at some point.

• Good sleep is underrated. It fixes a lot of other things that you probably don't even realize.

• Prioritize your health, physical and mental. You might have enough money to buy a villa in Norway but it's pretty much useless if you don't have the health to enjoy it.

• It's never over until it is over. Do not throw your chances away because you think you are unlucky. You never know.

• One way to deal with competition is to make it irrelevant.

And lastly, one of the most important things, if not the most important -

• Focus on the process. Your results are impacted by a lot of things that are beyond your control. If you are result-oriented, you'll never figure out what's right. Back yourself to do some amazing things in life provided you stick to your process, that is your right path.

No matter how lost you feel, if you stay true to yourself, the path will always find you again.

~ Enola Holmes' mother

With about 21 days left, I have to say that this is it for my dev journey this year.

It has been a lot of hustle and I can sense a lot of tired neurons upstairs.

I'll go through my ongoing examinations and probably just relax for the rest of the month. Thank you very much for reading through my journey.

Wishing everyone Happy Holidays, I'll see you in 2023. Cheers🥂

In this thread, let's look at a free alternative for Heroku, a relatively new company Render, that provides cloud infrastructure to deploy software and services.

What we'll need

1. A GitHub Account
2. A Render Account

Creating a simple Flask Application

Flask is one of my favourite Python frameworks because it's minimal and easy to use. The boilerplate code for Flask is barely 3-4 lines.

Let's create a standard endpoint that returns Hello world.

If you don't wish to start from scratch, you can clone this GitHub repository and proceed to the final step

Creating a Python Virtual Environment

Before we install Flask, we need to create a virtual environment that can store all our Python dependencies.

Let's open up the Command line and run these commands based on our Operating System to set up a virtual environment.

# Creating a new folder
mkdir sample-flask-app
cd sample-flask-app

# Linux
sudo apt-get install python3-venv    # If needed
python3 -m venv .venv
source .venv/bin/activate

# macOS
python3 -m venv .venv
source .venv/bin/activate

# Windows
py -3 -m venv .venv
# Use forward slashes if you are using Git Bash
.venv\scripts\activate

Installing Dependencies

After that, let's update the python package manager pip and install flask.

python -m pip install --upgrade pip
python -m pip install flask gunicorn

If you're wondering what gunicorn is, it's a tool that serves your Python code, i.e. your Flask app in production.

Setting up the Flask Application

Once we have our environment set up with the required dependencies, we can move forward to create our Flask Application.

To do so, create a python file with the name app.py in our project folder and open it in your favourite text editor cough I mean VSCode.

Now, let's write the code for creating a Flask application.

# Importing Flask
from flask import Flask, jsonify

# Creating an instance of the Flask class
app = Flask(__name__)

# Creating a new endpoint with this instance as a function decorator
@app.route('/')
def hello_world():
    return jsonify({
        "message": "Hello World."
    })

# Starting the Server
if __name__ == '__main__':
    app.run()

We can run python app.py on our command line to see whether everything works fine.

In a new shell window, we can use the curl command to see if the endpoint is working or look up localhost:5000 on the browser.

Now we know that our application is working fine. We can proceed towards deploying it.

Creating a requirements.txt file

When we deploy our application to Render, it runs on a remote cloud virtual machine. To ensure that the remote instance knows the dependencies we're using, we need to keep it updated in a separate file.

Let's run pip freeze > requirements.txt on our command-line.

We can see there is a new file requirements.txt that has been created.

On opening this file, we can look at the dependencies that are stored in our python environment.

We can remove all the sub-dependencies that may have popped up and just keep Flask and gunicorn.

Pushing the code to GitHub

Firstly, we need to create a new empty Repository on GitHub. Then, we'll have to initialize a local Git Repository on our system.

Run these commands in the same project folder to push your code to GitHub

# Initializing a Git repository
git init

# Creating a .gitignore file, adding the .venv directory to .gitignore
cat << EOF | sudo tee .gitignore 
.venv
EOF

# Adding Files to the staging area, making a commit
git branch -M main
git add .
git commit -m "Ready for deployment"

# Connecting the local repository to the public GitHub repository we previously created.
git remote add origin <link_to_github_repository.git>

# Pushing the changes
git push -u origin main

Our code is now on GitHub!

Deploying to Render

Once you sign up on Render, you'll be redirected to the Render Dashboard. Click on "Web Service" to proceed with our Deployment.

We can either connect our GitHub account or drop the link to a Public repository.

All we need to do now is to choose a name for our service and a region. I'll go with Singapore since that's the closest to my location.

Once that is done, click "Create Web Service" to deploy your application.

Results

In a few minutes, your application will be deployed on Render! You can look up the API using the provided domain name.

Congratulations, you've successfully deployed your Flask App to Render for free! I look forward to using Render for more server-side applications in the future. I hope you do as well.

Thanks for reading.

What is Code For Good?

CodeForGood is a social-good hackathon organized by JP Morgan Chase and Co. every year to provide software solutions to Social-Good Organizations (further referred to as SGOs).

The participants of this event (at least for India) are Second and Third Year Engineering Students who're in the process of recruitment for a Full-Time Role or a 6-month Internship at the company. These are students from Engineering Colleges across the country who have qualified from the Coding and Video-Interview Rounds.

For more about my experience in CFG, read this article.

The Problem Statement

The organization assigned to my team was Center for Gender and Politics (CGAP). They promote gender equality in politics with the help of awareness campaigns, blogs, etc. They function across South Asia.

They wanted a software solution to increase their audience to spread awareness about their initiative.

Our Approach

Given that we only had 24 hours to work on a solution, we thought of working on an approach where we tried to solve as many problems for the organization as possible. Here are some of the things that we initially listed down, which we thought we could fix.

• CGAP already had a blog as a part of its website. It just needed a better, more interactive user interface.
• CGAP had volunteers who collected stories across South Asia, sometimes in their regional languages. They had them stored scattered in Google Drive. They would like to work with a centralized database.
• CGAP's blogs were newsletters generated by a MacOS tool in PDF form, i.e. images put one after the other. It wouldn't be SEO friendly. An ideal solution would be to switch to Markdown, which would also help in incorporating meta tags to help improve SEO.

The Tech Stack

As a team, we decided to proceed with the following technologies given the simplicity of setup and working procedure.

• Frontend: Next.js
• Backend: Strapi.io (comes bundled with an API and an SQLite database by default)
• Python for Web Scraping

Our Solution

Web Scraping using Python

We used The Guardian's public API alongside Python to automate the scraping of stories from the internet. The idea was to showcase that we can automate the collection of stories across South Asia.

According to CGAP, this is the first step of getting stories on their blog. It is also the step that takes the longest due to its complexity. Any measures in automating this would save a lot of time.

Volunteer Recruitment using a Chat Bot

We thought that providing an AI chatbot would be an intuitive approach to onboard volunteers. The submissions would be stored in a CSV file, making it easier for the administration to manage them.

The Backend

We wanted a centralized database to simplify the collection and management of stories. The fact that Strapi comes with an admin panel also meant that it would make it easier for the volunteers to write articles, monitor and publish them.

Publishing articles from the backend was necessary because the collection of stories is handled from the backend too.

The Frontend

We aimed at having a relatively minimalist UI design for our blog front end since our primary focus was on functionality. We were able to split blogs into different categories to showcase them.

We were also showcasing articles written in regional languages.

Volunteer Dashboard

We also had an Authentication System for Volunteers to Sign In and monitor their progress in their blogs. The stage of progress was also dynamic, i.e. retrieved from the database.

Bonus: Text Summarization

We also added a simple feature for summarizing the text to be added to article excerpts. CGAP wanted article excerpts to be somewhere around 50-60 words.

Results

It was a lot of work to do in less than 24 hours alongside all the brainstorming, setup and making a presentation. I feel that completing this project as a team of 4 people was a huge accomplishment. The appreciation and positive feedback from the jury made it even more special.

Making it through the night, going through to the final round and winning the competition is another story. This hackathon has given me a lot of memories to cherish.