Kubernetes CronJobs are a powerful tool for running scheduled tasks within your Kubernetes cluster. Think of them as cron jobs for containers — they allow you to automate tasks like backups, batch jobs, or routine cleanups. In this guide, we'll walk through how to set up a CronJob in Kubernetes with a simple example.

What is a Kubernetes CronJob?

A CronJob in Kubernetes is essentially a job that runs on a scheduled basis. It allows you to run containers periodically, much like the cron utility on Linux, but with the added benefits of Kubernetes' orchestration.

When to Use Kubernetes CronJobs

CronJobs are ideal for tasks that need to run at specific intervals. For instance, you might use a CronJob for:

• Database backups that run every night.
• Sending email reports once a day.
• System cleanups that run weekly.

Setting Up a Kubernetes CronJob

To create a CronJob, you’ll define it in a YAML file, specifying the schedule and the task you want it to run. Here’s a basic example:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-backup
spec:
  schedule: "0 2 * * *"  # Run at 2 AM every day
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup-container
            image: my-backup-image:latest
            args:
            - /bin/sh
            - -c
            - "tar -czf /backup/daily-backup.tar.gz /data"
          restartPolicy: OnFailure

Breaking Down Kubernetes CronJob

• apiVersion: Defines the version of the Kubernetes API you're using.
• kind: Specifies that we're creating a CronJob.
• schedule: This is the cron syntax to set when the job runs. In this case, it’s set to run daily at 2:00 AM.
• jobTemplate: Defines the job itself. This includes:
  • container name: The name of the container you want to run.
  • image: The Docker image used for the container.
  • args: The commands executed by the container (in this case, a backup command).

Testing Your Kubernetes CronJob

Once you’ve applied the CronJob, you can check its status by running:

kubectl get cronjobs

To view the logs for a specific CronJob execution, use:

kubectl logs <pod-name>

If you need to troubleshoot, you can also describe the CronJob:

kubectl describe cronjob daily-backup

Managing Kubernetes CronJob Frequency

CronJob schedules follow the cron syntax, which looks like this:

* * * * *  
| | | | |  
| | | | +---- Day of the week (0 - 6) (Sunday=0)
| | | +------ Month (1 - 12)
| | +-------- Day of the month (1 - 31)
| +---------- Hour (0 - 23)
+------------ Minute (0 - 59)

For example:

• "0 3 * * *" runs the job at 3 AM every day.
• "*/15 * * * *" runs the job every 15 minutes.

Tip About Kubernetes Crons:

Make sure to also specify the startingDeadlineSeconds field to control how long the CronJob will wait for the job to complete before considering it failed. Avoid a Forever running job 😄

xAI Raises $5 Billion in New Funding

In its latest funding round, xAI raised $5 billion, boosting its valuation from $24 billion earlier this year. The company’s major backers include Sequoia Capital, Andreessen Horowitz, and Qatar’s sovereign wealth fund. Altogether, xAI has raised $11 billion in 2023, making it one of the fastest-growing AI companies.

xAI Valuation Now Higher Than X

The $50 billion xAI valuation is now far greater than X’s current worth. Fidelity, an investor in X, recently valued the social media platform at just $9.4 billion, a sharp drop from the $44 billion Musk paid to acquire it. This decline comes as X faces financial struggles, including a big drop in advertising revenue after several major brands left the platform.

Why Musk Founded xAI

Musk started xAI in 2023 as an alternative to OpenAI, the company he co-founded in 2015 but left in 2019. Musk has been critical of OpenAI for moving away from its original nonprofit goals. xAI aims to make advancements in AI while providing a fresh competitor in the market.

What’s Next for xAI?

With a strong $50 billion valuation and billions in funding, xAI is set to expand its influence in the AI industry. The company’s fast growth highlights the potential for AI startups to attract big investors and reshape the future of technology.

Elon Musk’s ambitious plans for xAI show that the AI industry is just getting started, and his company is leading the way.

In the realm of success and achievement, the concept of hard work often gets oversimplified.

Paul Graham, a luminary in the tech and startup world, offers an exploration of what it truly means to work hard in his enlightening essay, "How to Work Hard."

Through his rich narrative and insightful examples, Graham dismantles the conventional wisdom surrounding hard work, guiding us through the deeper layers of dedication and effort required to achieve greatness.

The Triumvirate of Success

At the heart of exceptional achievement lies a trio of critical components:

1. Natural ability
2. Practice
3. Effort

Graham introduces us to titans across various fields—Bill Gates in business, Lionel Messi in sports, and P.G. Wodehouse in literature—whose legendary successes stem not merely from their innate talents but from an unwavering commitment to hard work. These examples serve to underscore a crucial message: while talent is a significant part of the equation, it is the relentless pursuit of perfection and the willingness to put in an extraordinary amount of effort that truly sets the greats apart.

Debunking the Myth of Effortlessness

Graham challenges the myth that talent and hard work are mutually exclusive, a notion often glamorized by popular culture. This binary perspective overlooks the reality that the path to excellence is paved with both giftedness and grit. The essay advocate that both elements are essential for achieving outlier success.

Rediscovering the Meaning of Work

One of the most compelling aspects of Graham's essay is his personal reflection on the evolution of his work ethic, beginning with a decision at the age of 13 to stop watching TV. This anecdote marks the beginning of a journey towards understanding and embracing the true nature of work—a pursuit that goes beyond the confines of school assignments and enters the realm of self-imposed discipline and meaningful engagement.

Graham argues that real work possesses an inherent necessity, a criterion that transcends mere busywork. This realization often comes with maturity and is critical for those aiming to channel their efforts into genuine impact.

The Balancing Act of Hard Work

The quest for greatness is not about maximizing the number of hours spent working; it's about finding the optimal balance where effort enhances quality rather than detracts from it. Graham shares insights from his own experiences across different domains, highlighting the importance of recognizing one's limits and the delicate interplay between pushing oneself and maintaining the integrity of one's work.

A Call to Embrace the Hard Work Ethic

"Working hard towards greatness" is a dynamic process of setting goals, applying oneself fully, and being open to recalibrating one's path as needed. It demands an honest assessment of one's abilities and the humility to adapt. Graham in his essay, emphasis on the relationship between talent, hard work, and a passion for the craft.

In the essence, Paul Graham's reflections move beyond the conventional narratives of hard work, offering a profound and multifaceted understanding of what it takes to achieve greatness. His insights serve as a valuable guide for anyone looking to navigate the complexities of ambition, dedication, and success. Through the stories of renowned figures and personal anecdotes.

Graham's essay illuminates the path to greatness, revealing that at the intersection of talent and effort lies the true essence of hard work.

Introduction

ESP32 is pretty powerful micro-controller, when combined with power of python it can do a heck of work. We put together esp32 and micropython projects and created a Hack Guide for Esp32 and MicroPython containing tutorials focused on Network and Security. Here, we have our free part-1 of the guide.

Why MicroPython and ESP32?

MicroPython stands out as amazing implementation of Python 3, ideal for microcontrollers like the ESP32. Its simplicity, interactivity, and portability make it an excellent choice for programmers seeking an accessible yet powerful language. Paired with the ESP32's built-in Wi-Fi and Bluetooth capabilities, MicroPython becomes a perfect tool for network security for every programmer.

What this Free Mini Guide Covers

Our free mini-guide is perfect for beginners, with its complete knowledge and made in easy-to-use steps. Let's check into the guide's chapters, each designed to make network security easy for you

Topics Covered:

1. Installing MicroPython on ESP32

• Navigate through the installation process effortlessly
• Set up your development environment for MicroPython on ESP32

2. Calling a REST API from ESP32 with MicroPython

• Understand the basics of REST APIs
• Learn to interact with external services for enhanced functionality

3.Sending Emails using ESP32, MicroPython, and SendGrid

• Explore the intricacies of sending emails from your ESP32
• Utilize MicroPython to communicate with third party email APIs

4. Creating a Port Scanner using ESP32 and MicroPython

• Develop a robust port-scanning application
• Enhance your network security toolkit with MicroPython on ESP32

How to Get the Free Mini Guide

Download the guide from following link. Each chapter will help you to make more out of your esp32 projects

Follow us for next guide launch!

We are grateful to LaunchBulls who helped us bringing this guide to life. Follow this instagram and twitter/X for awesome products like this guide. Happy coding and learning!

206. Reverse Linked List Easy

Link : https://leetcode.com/problems/reverse-linked-list/

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example 1:

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Example 2:

Input: head = [1,2]
Output: [2,1]

Example 3:

Input: head = []
Output: []

Constraints:

• The number of nodes in the list is the range [0, 5000].
• -5000 <= Node.val <= 5000

Most Optimized C++ solution

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* ans = NULL;
        while(head){
            ListNode* tmp = new ListNode(head->val);
            tmp->next = ans;
            ans = tmp;
            head = head->next;
        }
        return ans;
    }
};

Reversing a Singly-Linked List

This solution focuses on taking a singly-linked list (think of it as a conga line where everyone holds the shoulder of the person in front of them) and reversing the order so that the first person ends up at the end and the last person leads the line.

How It Works

Imagine each person in the line stepping out and forming a new line in the opposite direction. This process ensures that the original order is completely reversed by the end.

1. Starting Point: We begin with an empty new line (ans), which will eventually become the reversed list.

2. Processing Each Person: As long as there are still people in the original line (head), we do the following for each person:

   • Create a new person (tmp) that is a copy of the current leader of the original line.
   • Have this new person point (next) to the current leader of the new line (ans). If the new line is empty, they just stand looking back at the empty space.
   • Move this new person to the front of the new line, making them the new leader (ans = tmp).
   • Move to the next person in the original line (head = head->next).

3. Completing the Reversal: This process repeats until there are no more people in the original line. Each iteration effectively moves the current person from the front of the original line to the front of the new line, reversing the order.

4. Final Step: Once the original line is empty, the new line (ans) is now the original line but in reverse order. We return this as the result.

Technical Explanation

• We initialize ans as NULL to signify the start of the new, reversed list.
• In each iteration of the loop, we:
  • Create a new node (tmp) with the same value as the current node pointed to by head.
  • Set tmp->next to ans, effectively placing it at the beginning of the new list.
  • Update ans to point to tmp, moving the front of the new list forward.
  • Move to the next node in the original list (head = head->next).
• Once head is NULL, indicating we've processed the entire original list, ans points to the head of the newly reversed list.

This algorithm ensures that the list is reversed with a linear time complexity relative to the length of the list, efficiently reordering the elements without modifying their values.

21. Merge Two Sorted Lists Easy

Link : https://leetcode.com/problems/merge-two-sorted-lists/

You are given the heads of two sorted linked lists list1 and list2.

Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists.

Return the head of the merged linked list.

Example 1:

Input: list1 = [1,2,4], list2 = [1,3,4]
Output: [1,1,2,3,4,4]

Example 2:

Input: list1 = [], list2 = []
Output: []

Example 3:

Input: list1 = [], list2 = [0]
Output: [0]

Constraints:

• The number of nodes in both lists is in the range [0, 50].
• -100 <= Node.val <= 100
• Both list1 and list2 are sorted in non-decreasing order.

Optimized solution in C++:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* res = new ListNode(-1);
        ListNode* ans = res;
        while(list1 && list2){
            if(list1->val <= list2->val){
                ans->next= new ListNode(list1->val);
                list1= list1->next;
            }
            else{
                ans->next= new ListNode(list2->val);
                list2= list2->next;
            }
            ans= ans->next;
        }
        if(list1){
            ans->next= list1;
        }
        if(list2){
            ans->next= list2;
        }
        return res->next;
    }
};

Solution Explanation:

Merging Two Sorted Lists

This solution is about combining two sorted lists (let's call them list1 and list2) into one single sorted list. Imagine you have two lines of people, each line is ordered by height. You want to form a new line that keeps everyone in order of height, pulling the shortest person available from the front of either line each time.

How It Works

1. Creating a Starting Point: First, we create an imaginary person (or a temporary starting node) that stands before the new line starts forming. This helps us easily add people to the new line without worrying about who is first.

2. Comparing Heights (Values): We look at the first person in each line. Whichever person is shorter (or if they're the same height, it doesn't matter which one we choose), we add them to the end of the new line and then step forward in the line they came from.

3. Repeating the Process: We keep doing this - comparing the first person in each line, adding the shorter one to the new line, and stepping forward in their line. If one line runs out of people, we simply add the rest of the people from the other line to the end of the new line.

4. Final Step: After we've gone through both lines entirely, our new line is complete. But remember the imaginary person we placed at the start? They're not actually part of the new line, so we make sure the new line starts with the first real person we added.

Technical Explanation

• A new list node (res) with a value of -1 is created to act as the starting point. The ans pointer is used to add new nodes to the list.
• As long as there are elements in both list1 and list2, we compare their values.
  • If list1's value is less than or equal to list2's, we add list1's value to the new list and move list1 forward.
  • Otherwise, we add list2's value and move list2 forward.
• If we reach the end of one list, we connect the remaining elements of the other list directly to the new list.
• Finally, since the first node (-1) was just a placeholder, we return the list starting from the next node, which is the actual start of our merged list.

This solution effectively merges two sorted lists into one, maintaining the sorted order, with a time complexity that is linear to the combined length of the two lists.

In this tutorial we will be coding our own port scanner for port scanning using esp32 and micropython. Please note that this is for educational purposes only. Scanning networks without permission can be illegal and unethical. Lets dive into a brief introduction of port scanning, why its unethical and then coding one for us.

What is Port Scanning?

Port scanning is a way to discover open spots, called ports, on a computer's network. This helps to understand which parts of the network or computer on network can talk to the outside world.

Why Port Scanning is Unethical?

Scanning ports on someone else's network is not only unethical but also illegal in many countries. Its similar to the methodically checking all doors and windows in a building to find which ones are open. Hackers usually use this method on a network or computer to see how far they can reach and what they can access on target computer or network.

Other uses of Port Scanning

You might have question, if its unethical why the hell this information is available so easily and people like me are giving away the code to perform this scan. The one major use of port scanning is in vulnerability scanning. To perform an assessment about how vulnerable a network is to cyber attacks or security breaches.

Code to Connect to The Network for Performing Scan

import network
import time

# Initialize Wi-Fi Interface
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

# wifi creds
ssid = '<YOUR WIFI SSID>'
password = '<YOU WIFI PASSWORD>'

print(wlan.isconnected())
time.sleep(0.5)

# Connect to the Wi-Fi network
wlan.connect(ssid, password)

print('Connected to Wi-Fi')

Complete Code for Port Scanner using Micropython

import socket
import time
import network

# Initialize Wi-Fi Interface
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

# wifi creds
ssid = '<YOUR WIFI SSID>'
password = '<YOU WIFI PASSWORD>'

print(wlan.isconnected())
time.sleep(0.5)

# Connect to the Wi-Fi network
wlan.connect(ssid, password)

print('Connected to Wi-Fi')

###
print(wlan.ifconfig())
###

def scan_port(ip, port):
    s = usocket.socket(usocket.AF_INET,usocket.SOCK_STREAM)
    try:
        s.settimeout(5)
        s.connect((ip, port))
        return True
    except OSError as e:
        # print(e) ## uncomment for debugging
        return False
    finally:
        s.close()

def port_scanner(ip, start_port, end_port):
    print("Scanning IP: ", ip)
    for port in range(start_port, end_port+1):
        if scan_port(ip, port):
            print("Port", port, "is open")
        else:
            print("Port", port, "is closed")

# Example usage
ip_to_scan = '198.1.0.1'  # Replace with the IP you want to scan
start_port = 1
end_port = 100  # Scanning 100 ports, adjust as needed


## starting port scaning
print("Running port scaning..")
port_scanner(ip_to_scan, start_port, end_port)

In above code, replace the value of ip_to_scan with the IP where you want to perform test and provide the range of ports in start_port and end_port. Save the code as main.py on you micropython enabled device.

Voila! you get your esp32 ready for port scanning !

Brevo (formally Sendinblue) is widely used for its reliability and ease of integration, offers a REST API for sending emails. In this tutorial we will go step by step about how to send email using esp32 with micropython and brevo

Prerequisites

1. ESP32 Module: With MicroPython firmware installed.
2. Brevo Account: Sign up for a free brevo account here.
3. Brevo API Key: Create an API key in your Brevo account.

Step-by-Step Guide

Step 1: Setting Up Your Environment

1. Connect ESP32 to Your Computer
2. Use Thonny to write and save your code

Step 2: Code to Connect ESP32 to Wi-Fi

import network

##### Initialize Wi-Fi Interface
wlan = network.WLAN(network.STA_IF)
wlan.active(True)


#### wifi creds
ssid = '<YOUR-SSID>'
password = '<YOUR-PASSWORD>'

print(wlan.isconnected())
time.sleep(0.5)

# Connect to the Wi-Fi network
wlan.connect(ssid, password)

Step 3: Upload the urequests library to esp32

This library can be single file named urequests.py or a folder named "urequests" with a "__init__.py" file inside. In the code example attached I used the library with folder. You can download the file from here and extract the init file to urequests folder inside root directory of esp32.
It should look like this: /urequests/__init__.py

Step 4: Sending an Email using Brevo API

import urequests
import ujson

brevo_api_key = '<YOUR-API-KEY-HERE>'

url = 'https://api.brevo.com/v3/smtp/email'

headers = {
    'accept': 'application/json',
    'api-key': brevo_api_key,
    'content-type': 'application/json',
}

data = {
    "sender": {
        "name": "ESP32 CLIENT",
        "email": "<YOUR-EMAIL-ID>"
    },
    "to": [
        {
            "email": "<RECEIVER-EMAIL-ID>",
            "name": "<RECEIVER NAME>"
        }
    ],
    "subject": "Hello world from Esp32",
    "htmlContent": "<html><head></head><body><p>Hello,</p>This is my first test email sent from esp32 using Brevo.</p></body></html>"
}

response = urequests.post(url, data=ujson.dumps(data), headers=headers)

Complete Code for sending email from esp32

import urequests
import ujson
import network
import time

# Initialize Wi-Fi Interface
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

wlan.disconnect()

# wifi creds
ssid = '<YOUR-SSID>'
password = '<YOUR-PASSWORD>'

print(wlan.isconnected())
time.sleep(0.5)

# Connect to the Wi-Fi network
wlan.connect(ssid, password)

print('Connected to Wi-Fi')

brevo_api_key = '<YOUR-API-KEY-HERE>'

url = 'https://api.brevo.com/v3/smtp/email'

headers = {
    'accept': 'application/json',
    'api-key': brevo_api_key,
    'content-type': 'application/json',
}

data = {
    "sender": {
        "name": "ESP32 CLIENT",
        "email": "<YOUR-EMAIL-ID>"
    },
    "to": [
        {
            "email": "<RECEIVER-EMAIL-ID>",
            "name": "<RECEIVER NAME>"
        }
    ],
    "subject": "Hello world from Esp32",
    "htmlContent": "<html><head></head><body><p>Hello,</p>This is my first test email sent from esp32 using Brevo.</p></body></html>"
}

response = urequests.post(url, data=ujson.dumps(data), headers=headers)


if response.status_code == 201:
    print("Email sent successfully!")
else:
    print("Failed to send email. Response:", response.text)
response.close()

Voila! this is all you need to send email from esp32. You can download this code with requests library in the file below and place on your esp32 (add your api key and emails) in places like <YOUR-API-KEY-HERE>

To call a REST API from an ESP32 using MicroPython, you'll typically need to connect the ESP32 to a Wi-Fi network and then use HTTP methods to interact with the API. Below is a step-by-step tutorial to achieve this.

We will use micropython in this tutorial to call REST API from ESP32:

What do you need

1. ESP32 with MicroPython Installed: Learn how to install micropython on esp32 here
2. Wi-Fi network Details (SSID and password).

Step 1: Code to Connect ESP32 to Wi-Fi

import network

# Initialize Wi-Fi Interface
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

# wifi creds
ssid = 'your_wifi_ssid'
password = 'your_wifi_password'

# Connect to Your Wi-Fi:
while not wlan.isconnected():
    pass
print('Connected to Wi-Fi'))

Step 2: Install urequests Library (If Not Present)

The urequests library is used for making HTTP requests. It may or may not be included in your MicroPython firmware (its included in latest micropython).

If you are using older version of micropython, lets download the urequest with this simple step:
Download the file from here and save it on the root directory of your esp32 (using thonny or any file transfer tool like ampy). Using thonny it will be easier.

Step 3: Code to Call REST API

import urequests

# calling a publicaly available REST API
url = 'http://api.example.com/data'
response = urequests.get(url)

# checking the response
if response.status_code == 200:
   print(response.text) # printing API response
else:
  print('Failed. Error code:', response.status_code)

Step 4: Run Your Code (complete code here)

import network
import urequests

# Initialize Wi-Fi Interface
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

# wifi creds
ssid = 'your_wifi_ssid'
password = 'your_wifi_password'

# Connect to Your Wi-Fi:
while not wlan.isconnected():
    pass
print('Connected to Wi-Fi'))

# calling a publicaly available REST API

url = 'https://dog.ceo/api/breeds/list/all' # you can use your API url here
response = urequests.get(url)

# checking the response
if response.status_code == 200:
   print(response.text) # printing API response
else:
  print('Failed. Error code:', response.status_code)

1. save above code file named as main.py and transfer to your esp32 (using thonny). You can also directly save file using thonny to your esp32. (shown in image)

1. Reset esp32 and you will see the API call going from esp32, result will be printed on console (thonny' console).

Step 5: Verify the Output

Check the output on the serial console (thonny's serial console). You should see the response from the REST API! Cheers

In this how to install micropython on esp32 tutorial, we will download the official micropython binaries and flash them to esp32. Then verify the working of micropython on esp32.

What You Need:

1. ESP32 Module: This is the hardware you'll be programming.
2. Micro USB Cable: To connect ESP32 to your computer.
3. Computer: With internet access to download necessary files and software.

Steps to install micropython on esp32:

Step 1: Download the Firmware

1. Go to the MicroPython Website: Visit the MicroPython downloads page.
2. Select Firmware for ESP32: Look for the section labeled 'Firmware for ESP32 boards'.
3. Download the Latest Version: Click on the link to download the latest firmware (.bin file) to your computer.

Step 2: Install esptool.py

1. Install Python: Make sure you have Python installed on your computer. You can download it from the Python official website.
2. Open Command Line: Open Command Prompt (Windows) or Terminal (macOS/Linux).
3. Install esptool: Type pip install esptool and press Enter. This tool is used to communicate with the ESP32 chip. Link to documentation

Step 3: Connect ESP32 to Computer

1. Plug in Your ESP32: Use the micro USB cable to connect the ESP32 to your computer.
2. Check the COM Port:
   • On Windows, open Device Manager and look under 'Ports (COM & LPT)' to find out which COM port the ESP32 is connected to.
   • On macOS/Linux, open Terminal and type ls /dev/tty.* to list the devices connected.

Step 4: Erase the Flash

1. Open Command Line: If you closed it earlier, open it again.
2. Go to the ESP32 Port: Type esptool.py --port COMx erase_flash (replace 'COMx' with the correct COM port).
3. Execute the Command: Press Enter to erase the existing flash on the ESP32.

Step 5: Flash MicroPython

1. Locate the Downloaded Firmware: Find where you saved the .bin file (that you downloaded in step 1)
2. Flash the Firmware: Type esptool.py --port COMx --baud 460800 write_flash -z 0x1000 path-to-your-downloaded.bin (replace 'COMx' with your COM port and 'path-to-your-downloaded.bin' with the path to the downloaded .bin file).

Step 6: Verify Installation

Verify installation using Thonny

One simple way to verify the installation is install thonny and select your COM Port or tty connected device from settings. You will see the >>> sign on thonny's shell indicating that micropython is installed.

Verify installation using Putty on windows:

1. Install a Serial Terminal: Install a program like PuTTY or use the built-in terminal for communication. Open the serial terminal, select the COM port, set the baud rate to 115200, and connect.
2. Check for MicroPython Prompt: You should see the MicroPython prompt >>>. If you see this, congratulations, MicroPython is installed!

You've successfully installed MicroPython on your ESP32. Enjoy! To see what you can do using micropython, I have a tutorial to host a website using micropython here

Entrepreneurs are always on the lookout for resources that can provide insights, inspiration, and practical advice. Newsletters, packed with startup stories, can be a goldmine of information especially when they are free. I subscribed to multiples and read many, here are my top three picks, each offering unique perspectives and invaluable lessons from the startup universe.

1. Startup Digest

Why It's My Top Pick: Startup Digest stands out for its comprehensive coverage and customization. It's more than just a newsletter; it's a curated experience tailored to your interests. Whether you're interested in fintech, healthtech, or any other sector, Startup Digest has got you covered.

What You'll Get: Subscribers receive a weekly digest of the latest trends, stories, and tips from various startup sectors. The content is rich and varied, offering something for everyone. The personalized approach means you get the most relevant information, saving you time and keeping you focused on your niche.

2. The Hustle

Why It Ranks Second: The Hustle is perfect for those who want their startup news with a side of personality. It’s known for its conversational tone and ability to dissect complex topics into enjoyable reads.

What You'll Get: Daily updates provide a mix of the latest startup news, technology trends, and business strategies. The newsletter has a knack for unearthing fascinating stories and presenting them in a way that's both informative and entertaining. If you're looking for a daily dose of startup insights that feels like a chat with a knowledgeable friend, The Hustle is for you.

3. FounderPedia.app

Why It's a Must-Subscribe: FounderPedia earns its place for its focused and deep-diving content. While it may not have the broad appeal of Startup Digest or the daily frequency of The Hustle, it stands out for its in-depth case studies.

What You'll Get: This newsletter is offering detailed startup stories that go beyond the surface. Each issue is a deep dive into a single startup's journey, offering lessons learned, strategies employed, and the real-world challenges faced. For those looking to understand the essentials and backstage of building a startup, FounderPedia is an invaluable resource.
You can check this out here: https://founderpedia.app/

Bonus - Lenny's Newsletter

I recently came accross it and its more that only a newsletter as Lenny has podcast and youtube channel. I am putting it in a bonus list. If you are behind the secret recipe of success, this is must read newsletter on substack.
You can check the stories out here: https://www.lennysnewsletter.com/

Final Thoughts

Each of these newsletters brings something unique to the table. For entrepreneurs seeking knowledge, inspiration, and practical advice, subscribing to these free newsletters is a step towards informed and successful entrepreneurship.

Note: The opinions expressed in this blog post are based on my personal experiences and preferences. The ranking and descriptions are intended to guide readers towards resources that could be beneficial in their entrepreneurial journey.

ESP32 is famous micro-controller for hobby and commercial projects. In this tutorial, we'll explore how to host a website on an ESP32 using the Microdot framework.

What is Microdot?

Microdot is a lightweight Python web framework designed for light weight operations. It offers a minimalist yet efficient way to create web applications. Its light weight makes it excellent choice for microcontrollers like the ESP32.

Prerequisites

Before diving into the ESP32 webserver setup, make sure you have the following:

• An ESP32 microcontroller with MicroPython firmware installed.
• A development environment (e.g., Thonny or VS Code with PlatformIO) ready to go.
• The Microdot library (we'll guide you through the installation).

Installing Microdot on Your ESP32

To get started hosting a website on your ESP32, you'll need to install the Microdot framework. Follow these steps:

1. Download and Install the Microdot Library

Begin by downloading the Microdot library from the official GitHub repository. You need to download micropython.py file and place it in the root directory of esp32.
Official Download link

2. Create Your ESP32 Web Application

With Microdot installed, you can start building your web application. Use the provided code as a starting point:

from microdot import Microdot
from microdot import send_file
import network

# Set your Wi-Fi credentials - We need them to connect the ESP32 to your network
ssid = 'your_SSID'
password = 'your_PASSWORD'

# Create a Wi-Fi station (STA) interface
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)

# Connect to the Wi-Fi network
sta_if.connect(ssid, password)

# Wait until the ESP32 is connected to the network
while not sta_if.isconnected():
    pass
print('Connected to Wi-Fi')


# web server code starts here
app = Microdot()

@app.route('/')
def index(request):
    return send_file('index.html')

app.run(port=80)

NB: Update your wifi ssid (name) and password in above code

Save above code in your code.py on root directory of ESP32. This code connect esp32 to network and creates a web application serving an index.html file when you access the root URL.

3. Create a basic HTML file

<html>
<title> Website Hosted on Esp32 </title>
<body>
<p> Hello World ! </p>
<p> This website is hosted on esp32 </p>
</body>
</html>

I used little css in my esp32 website here

4. Upload the Web Files

Now, upload your web files, named as index.html file, to your ESP32. Make sure you copy the file at the root directory.

5. Start the ESP32 Web Server

Restart your ESP32 to start the web server (make sure the micropython is installed before you install microdot).

6. Access Your ESP32 Webserver

Once it is running, you can access your website by entering your ESP32's IP address in a web browser. For example, if your ESP32's IP address is 192.168.1.100, input http://192.168.1.100 in your browser.
(To find the IP of ESP32 device, one of the easiest way is to check from device connected list of your router)

Congratulations! You've successfully hosted a website on your ESP32 webserver like my esp32 website.
Like to discuss or see more projects like this, connect with me at LinkedIn here!

In this tutorial, we will walk through the process of Dockerize FlasK Python service step by step. Docker and flask is an easy example of containerizing a python application.

Docker is a platform that offer containerization solution for software applications, and python is our favourite and powerful language. Let’s combine the power of both.
What about Flask, this is a web framework that is written in python and use to build web applications using python.

In current tutorial, we will be using web python application. For very basic or command line python application (hello world program) using docker, please follow this tutorial

1. Prerequisites

Before we begin, ensure that you have the following tools installed on your system:

• Docker: Download and install Docker from the official website.
• Python: Download and install Python from the official website.

2. Create a Python Service

For the purpose of this tutorial, we will create a simple Python service that exposes a “Hello, World!” message via a REST API using the Flask web framework.

Create a directory for your project and create a Python script named app.py with following code:

# app.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

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

Now, create a requirements.txt file to list the Python packages required for your service, with the following line in it:

Flask==2.0.1

3. Write a Dockerfile

A Dockerfile is a script used to build a Docker image. Create a file named Dockerfile (no file extension) in the same directory as your Python script app.py and requirements.txt with the following content:

# Use the official Python image as the base image
FROM python:3.8-slim

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Expose port 80
EXPOSE 80

# Define the command to run your application
CMD ["python", "app.py"]

You can name this file: Dockerfile without any extension

This Dockerfile does the following:

• It starts with the official Python 3.8 image.
• Sets the working directory to /app in the container.
• Copies the contents of the current directory (your Python code and requirements.txt) to the container.
• Installs the Python dependencies listed in requirements.txt.
• Exposes port 80 (the default for HTTP).
• Specifies the command to run your application, which is python app.py.

4. Build the Docker Image

Navigate to the directory containing your Dockerfile and Python code in your terminal and run the following command to build the Docker image:

docker build -t python-service .

• -t python-service assigns the name “python-service” to your Docker image. You can choose any name you like. This is to tag the docker image with specific name.
  

5. Run the Docker Container

Now that you have built the Docker image, you can run a Docker container from it. Use the following command:

docker run -d -p 8080:80 python-service

• -d runs the container in detached mode.
• -p 8080:80 maps port 8080 on your host machine to port 80 in the container.
• python-service is the name of the image you built earlier.

Congratulations! You’ve successfully Dockerized a Python service. Your Flask-based “Hello, World!” service is now running in a Docker container and accessible at http://localhost:8080 in your web browser.