DEV Community: Harshavardhan

Six Months of Growth: My B.Tech Journey Through Python, AI, Full Stack Development & ECE

Harshavardhan — Wed, 06 May 2026 13:29:07 +0000

Introduction

B.Tech semesters often feel like a race against deadlines, exams, and assignments. But this semester, I decided to approach it differently - as a structured learning journey across multiple domains. Over the past 6 months, I immersed myself in 11 courses spanning Python Full Stack Development, Artificial Intelligence & Machine Learning, VLSI Design, Digital Communication, Network Protocols, and more.

This post documents my semester journey - what I learned, the challenges I faced, key takeaways, and how each course contributed to building a well-rounded engineering profile.

Course Overview
Global Logic Building Contest Practicum
Coding Skills Training - Algorithms
Python Full Stack Development
AI & ML Using Python (Industrial Automation)
Machine Learning with Python Programming
VLSI Design & Digital VLSI Design
Electromagnetic Waves & Transmission Lines
Digital Communication
Network Protocols & Security
Volleyball - Beyond the Classroom
Key Lessons Learned
What's Next?

Course Overview

Here's a quick snapshot of all the courses I took this semester:

Course Area	Courses	Department
Competitive Coding	Global Logic Building Contest, Coding Skills Training	CSE
Development	Python Full Stack Development	CSE
AI/ML	AI & ML using Python, Machine Learning with Python	ECE
Core ECE	VLSI Design, Digital VLSI Design, EM Waves, Digital Communication	ECE
Networking	Network Protocols & Security	ECE
Sports	Volleyball	CSE

Global Logic Building Contest Practicum

What It Was

A hands-on competitive programming practicum where we solved real-world logic puzzles and coding challenges under time constraints - similar to hackathon and product team environments.

What I Learned

Problem Decomposition: Breaking complex problems into smaller, solvable parts
Time Management: Delivering working solutions under strict deadlines
Feedback Loops: Iterating on code based on peer and mentor reviews
Test-Driven Thinking: Writing test cases before implementing solutions

Key Takeaway

The biggest shift was moving from "getting the right answer" to "building a solution that works under constraints."

Coding Skills Training - Algorithms

Focus Areas

This course was all about strengthening my DSA foundation specifically for campus recruitment:

Time & Space Complexity - Big-O analysis of algorithms
Two Pointers Pattern - Efficient array traversal techniques
Sliding Window - Subarray and substring optimization problems
Recursion & Backtracking - Solving combinatorial problems
Dynamic Programming - Memoization and tabulation approaches

Sample Code: Sliding Window Pattern

def max_subarray_sum(arr, k):
    window_sum = sum(arr[:k])
    max_sum = window_sum

    for i in range(k, len(arr)):
        window_sum += arr[i] - arr[i-k]
        max_sum = max(max_sum, window_sum)

    return max_sum

# Example: max_subarray_sum([2, 1, 5, 1, 3, 2], 3) = 9

Challenges I Faced

Challenge	Problem	Solution
Identifying Patterns	Couldn't recognize which algorithm to apply	Practiced 50+ pattern-based problems on LeetCode
Optimization	Initial solutions were O(n^2)	Learned to use hashmaps and two-pointer techniques
Recursion Depth	Stack overflow on deep recursion	Switched to iterative approaches with explicit stacks

Python Full Stack Development

Tech Stack Covered

Backend: Python (Flask/Django)
Frontend: HTML, CSS, JavaScript
Database: MySQL / PostgreSQL
APIs: RESTful API design and consumption

What I Built

A full-stack web application with user authentication
REST APIs with proper routing and error handling
Database models with relationships and migrations
Responsive frontend with modern CSS frameworks

Why It Matters

This course bridged the gap between my ECE hardware knowledge and software development. Understanding how frontend, backend, and databases interact gave me a holistic view of building production-ready applications.

AI & ML Using Python (Industrial Automation)

Course Focus

This course applied machine learning concepts specifically to industrial automation scenarios - making it highly practical for real-world deployment.

Topics Covered

Data Preprocessing - Cleaning, normalization, and feature engineering
Supervised Learning - Regression and classification algorithms
Model Evaluation - Cross-validation, confusion matrices, ROC-AUC
Industrial Applications - Predictive maintenance, quality control, anomaly detection

Code Snippet: Building a Classifier

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Train model
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Evaluate
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

Industrial Automation Insight

Understanding how ML models integrate with PLCs, SCADA systems, and IoT sensors opened my eyes to the massive potential of AI in manufacturing and process optimization.

Machine Learning with Python Programming

What Made This Different

While the Industrial Automation course focused on applications, this course went deeper into the mathematics and implementation of ML algorithms from scratch.

Key Concepts Mastered

Gradient Descent - Understanding how models learn from data
Regularization - L1 (Lasso) and L2 (Ridge) techniques to prevent overfitting
Ensemble Methods - Bagging, Boosting, and Stacking
Hyperparameter Tuning - GridSearchCV and RandomizedSearchCV

My Biggest Challenge

Implementing algorithms from scratch without relying on scikit-learn forced me to truly understand the underlying math - linear algebra, calculus, and probability theory all came together.

VLSI Design & Digital VLSI Design

What Is VLSI?

VLSI (Very Large Scale Integration) is the process of creating integrated circuits by combining thousands to millions of transistors into a single chip.

What I Learned

CMOS Technology - How transistors work at the silicon level
Logic Gate Design - Building AND, OR, NOT, NAND, NOR gates from transistors
Sequential Circuits - Flip-flops, latches, and state machines
VHDL/Verilog - Hardware Description Languages for digital design
FPGA Implementation - Programming Field Programmable Gate Arrays

Code Example: Verilog D Flip-Flop

module d_flip_flop (
    input wire clk,
    input wire d,
    input wire reset,
    output reg q
);

always @(posedge clk or posedge reset) begin
    if (reset)
        q <= 1'b0;
    else
        q <= d;
end

endmodule

Why It Matters

Understanding how software runs on hardware at the transistor level gives me a unique perspective that pure software engineers often miss.

Electromagnetic Waves & Transmission Lines

Course Overview

This course explored how electromagnetic waves propagate through different media and how transmission lines carry signals over distances.

Key Concepts

Topic	Key Learning
Maxwell's Equations	Foundation of all EM wave theory
Wave Propagation	How waves travel in free space and guided media
Transmission Line Theory	Impedance matching, standing waves, VSWR
Smith Chart	Visual tool for impedance matching
Antenna Fundamentals	Radiation patterns and gain

Real-World Application

Understanding transmission lines is critical for designing PCBs, RF circuits, and communication systems - directly applicable to IoT and wireless communication projects.

Digital Communication

What I Studied

Digital Communication is about transmitting information digitally over channels - the backbone of every modern communication system.

Topics Covered

Source & Channel Coding - Huffman coding, error detection/correction
Modulation Techniques - ASK, FSK, PSK, QAM
Sampling & Quantization - Nyquist theorem, PCM
Multiplexing - TDM, FDM, CDMA

Code Example: BPSK Modulation Simulation

import numpy as np
import matplotlib.pyplot as plt

# BPSK Modulation
def bpsk_modulate(bits):
    return np.array([1 if b == 1 else -1 for b in bits])

# Generate random bits
bits = np.random.randint(0, 2, 100)
modulated = bpsk_modulate(bits)

# Plot constellation
plt.scatter(modulated, np.zeros_like(modulated))
plt.title('BPSK Constellation Diagram')
plt.show()

Network Protocols & Security

Course Highlights

This course covered how data moves across networks and how to secure it.

Key Protocols Studied

TCP/IP Stack - Application, Transport, Network, and Data Link layers
HTTP/HTTPS - Web communication and TLS encryption
DNS, DHCP, ARP - Core network services
Firewall & IDS - Intrusion detection and prevention

Security Concepts

Concept	Description
Encryption	Protecting data using cryptographic algorithms
Authentication	Verifying user identity
Authorization	Controlling access to resources
Integrity	Ensuring data hasn't been tampered with
Non-repudiation	Preventing denial of actions

Volleyball - Beyond the Classroom

Why It Matters

Engineering isn't just about sitting in front of a computer. Playing volleyball taught me:

Discipline - Regular practice builds consistency
Teamwork Under Pressure - Coordinating with teammates in high-stakes matches
Mental Health Balance - Physical activity as a stress reliever during intense study periods
Strategic Thinking - Reading the game and adapting tactics on the fly

Key Lessons Learned

1. Multidisciplinary Knowledge Is Power

Combining software (Python, Full Stack, ML) with hardware (VLSI, EM Waves, Digital Communication) gives me a unique edge in fields like embedded AI, IoT, and industrial automation.

2. Consistency Beats Intensity

Rather than cramming before exams, spreading study time across the semester and building projects along the way made learning more effective and less stressful.

3. Connect Theory with Practice

Every concept became meaningful when I applied it - whether implementing an ML model, designing a digital circuit, or building a web app.

4. Community Matters

Engaging with peers, sharing code, and discussing concepts made difficult topics easier to understand.

What's Next?

This semester laid a strong foundation, but the journey is far from over. Here's what I'm planning:

Build end-to-end projects that combine ML models with web applications
Contribute to open source projects in AI and embedded systems
Explore Edge AI - deploying ML models on edge devices
Share more tutorials and technical blogs on this community
Connect with mentors working in AI, full stack, and embedded systems

Let's Connect!

If you're also a B.Tech student navigating multiple domains, or if you're working in AI, full stack, or embedded systems, I'd love to connect and exchange ideas.

GitHub: https://github.com/Born-as-Harsha
LinkedIn: @harshaabhi

Summary

Key Takeaways:

11 courses across CSE and ECE departments in one semester
Hands-on experience in Python, ML, Full Stack, VLSI, and Networking
Balanced academics with sports and personal development
Ready to build real-world projects combining software and hardware

Your turn: What's your current learning focus? Drop a comment below!

Thank you for reading! If you found this helpful, please share and follow me for more content about AI, full stack development, and my coding journey!

The Path Toward Embedded Systems Expertise

Harshavardhan — Thu, 20 Nov 2025 18:33:53 +0000

"The journey of a thousand instructions begins with a single bit"

By Harshavardhan | Department of Electronics & Communication Engineering

A Chronicle of Passion, Perseverance, and Processors

The Beginning: A Spark of Curiosity

Six months ago, I stood at the threshold of a world I barely understood—a realm where software meets hardware, where abstract code transforms into tangible motion, light, and sound. The course was Processors and Controllers, and little did I know, it would fundamentally change how I perceive technology.

This isn't just a technical blog. This is the story of late nights debugging circuits, the euphoria of seeing an LED blink for the first time, and the profound satisfaction of making a stepper motor dance to my code. Welcome to my journey.

Chapter 1: The 8086 Foundation
Chapter 2: Enter the 8051
Chapter 3: The Interfacing Chronicles
Chapter 4: Hardware Realization
Chapter 5: Advanced Architectures
Chapter 6: Reflection & Future

Chapter 1: The 8086 Foundation - Where Legends Begin

Learning to Think Like a Machine

The Challenge: Understanding how processors actually think

The Intel 8086 microprocessor wasn't just my first subject—it was my initiation into the ancient art of low-level programming. Imagine learning a new language where every word directly controls a machine's behavior. That's assembly language.

Architecture: The Blueprint of Intelligence

The 8086's architecture felt like exploring a meticulously designed city with two main districts:

1. Bus Interface Unit (BIU) - The Communication Hub

Handles all external bus operations
Contains segment registers (CS, DS, SS, ES)
Manages the 6-byte instruction queue
Calculates physical addresses

2. Execution Unit (EU) - The Processing Core

Contains ALU (Arithmetic Logic Unit)
Houses general-purpose registers (AX, BX, CX, DX)
Executes instructions decoded from the queue
Manages flags register

The Register Set: Your Programming Palette

Understanding registers was like learning the tools of a master craftsman. Each 16-bit register could be split into two 8-bit registers (AH/AL, BH/BL, CH/CL, DH/DL). The elegance of the design clicked. This wasn't just engineering—this was art.

Register	Purpose	Function
AX	Accumulator	Primary arithmetic
BX	Base	Addressing
CX	Count	Loop operations
DX	Data	I/O operations

Memory Segmentation: The 1MB Puzzle

The 8086 has 16-bit registers but needs to access 1MB (20-bit address space). The solution:

Physical Address = (Segment Register × 16) + Offset

Example:

Segment (CS) = 1234H
Offset (IP) = 5678H
Physical Address = 12340H + 5678H = 179B8H

My First Programs: Baby Steps to Giant Leaps

The evolution moved from simple addition to implementing:

Bubble sort algorithms
String reversal
Factorial calculations
Array manipulations

.MODEL SMALL
.STACK 100H
.DATA
    NUM1 DW 1234H
    NUM2 DW 5678H
    RESULT DW ?
.CODE
MAIN PROC
    MOV AX, @DATA
    MOV DS, AX

    MOV AX, NUM1
    ADD AX, NUM2
    MOV RESULT, AX

    MOV AH, 4CH
    INT 21H
MAIN ENDP
END MAIN

Key Takeaways from Phase 1

✅ Assembly language teaches you to think in terms of machine cycles
✅ Every high-level language ultimately compiles down to these basic operations
✅ Understanding registers and memory is fundamental to all computing
✅ Optimization at assembly level can make programs exponentially faster

Status: Foundation solid. Ready for real hardware.

Chapter 2: Enter the 8051 - When Code Meets Reality

From Virtual to Physical

If 8086 was learning the alphabet, 8051 was writing poetry. This wasn't simulation anymore—this was real.

The 8051 Architecture: A Masterpiece of Integration

What Makes 8051 Special?

The 8051 isn't just a processor—it's a complete system on a chip:

✓ 8-bit CPU
✓ 4KB ROM (Program Memory)
✓ 128 Bytes RAM (Data Memory)
✓ 4 x 8-bit I/O Ports (P0, P1, P2, P3)
✓ 2 x 16-bit Timers/Counters
✓ Full-Duplex UART
✓ 6 Interrupt Sources
✓ Boolean Processor (Bit Manipulation)

The Pin Configuration: Gateway to the Physical World

40 pins. Each one a potential connection to something amazing.

Port Functions:

P0 (Port 0): Multiplexed address/data bus
P1 (Port 1): Pure I/O port (my favorite for quick tests!)
P2 (Port 2): High-order address/I/O
P3 (Port 3): Dual-function (I/O + special functions)

Programming Paradigm Shift

Moving from 8086 assembly to 8051 C programming felt like upgrading from a manual transmission to automatic—more power, more control, more possibilities.

The First Blink

The Moment: When this code made a real LED blink on a real board, I understood what embedded systems engineering truly meant.

Timers: The Heartbeat of Embedded Systems

Timers weren't just another feature—they were the key to precise control.

Timer Modes:

Mode 0: 13-bit timer/counter
Mode 1: 16-bit timer/counter (most used)
Mode 2: 8-bit auto-reload
Mode 3: Split timer mode

#include <reg51.h>

void delay(unsigned int time) {
    unsigned int i, j;
    for(i = 0; i < time; i++)
        for(j = 0; j < 1275; j++);
}

void main() {
    while(1) {
        P1 = 0xFF;    // All pins HIGH
        delay(1000);  // Wait
        P1 = 0x00;    // All pins LOW
        delay(1000);  // Wait
    }
}

Chapter 3: The Interfacing Chronicles - Bringing Projects to Life

Where Theory Becomes Tangible

This phase was pure magic. Every successful interface was a victory, every glowing LED a celebration.

Project 1: LED Interfacing - Hello, Physical World!

The Setup:

8 LEDs connected to Port 1
Current-limiting resistors (220 ohm each)
Common cathode configuration

The Code Evolution:

// Stage 1: Basic Blink
P1 = 0xFF; delay(); 
P1 = 0x00; delay();

// Stage 3: Complex Patterns
for(i = 0; i < 8; i++) {
    P1 = (1 << i);
    delay();
}

unsigned char patterns[] = {0x18, 0x24, 0x42, 0x81};

What I Learned: The simplest circuits teach the deepest lessons about digital logic and timing.

Project 2: LCD Interface - My Digital Canvas

The Mission: Display "Harshavardhan" and my department ID on a 16x2 LCD

The Hardware:

16x2 Character LCD (HD44780 controller)
4-bit mode interface (saves pins!)
Contrast control via potentiometer

The LCD Dance: Initialization Sequence

void lcd_init() {
    lcd_command(0x02);  // Return home
    lcd_command(0x28);  // 4-bit, 2 line, 5x7 matrix
    lcd_command(0x0C);  // Display ON, cursor OFF
    lcd_command(0x06);  // Increment cursor
    lcd_command(0x01);  // Clear display
    delay(2);
}

void main() {
    lcd_init();
    lcd_command(0x80);              
    lcd_string("Harshavardhan");
    lcd_command(0xC0);              
    lcd_string("ECE Department");
    while(1);
}

The Feeling: Indescribable. My code, my name, glowing on a physical display. This was the moment I truly became an embedded systems engineer.

Project 3: ADC Interface - Reading the Analog World

The Bridge Between Worlds: ADC0804 - Converting continuous analog signals to discrete digital values

Technical Specifications:

8-bit resolution (256 discrete levels)
0-5V input range
Successive approximation architecture
Conversion time: ~100 microseconds

Real-World Application: Temperature Monitoring

unsigned char read_adc() {
    WR = 0;            // Start conversion
    delay_us(10);
    WR = 1;
    while(INTR == 1);  // Wait for conversion
    RD = 0;            // Read data
    unsigned char data = ADC_PORT;
    RD = 1;
    return data;
}

void display_temperature() {
    unsigned char adc_value = read_adc();
    float temperature = (adc_value * 5.0 / 255.0) * 100;
    lcd_command(0x80);
    lcd_string("Temp: ");
    lcd_number(temperature);
}

The Marvel: Watching real-world temperature changes reflected instantly on my display made physics and electronics merge beautifully.

Project 4: DAC Interface - Creating Analog from Digital

The Reverse Journey: Digital to Analog Converter - DAC0808

Waveform Generation

void generate_square() {
    while(1) {
        DAC_PORT = 0xFF;    // Maximum voltage
        delay_ms(10);
        DAC_PORT = 0x00;    // Minimum voltage
        delay_ms(10);
    }
}

void generate_triangular() {
    unsigned char i;
    while(1) {
        // Rising edge
        for(i = 0; i < 255; i++) {
            DAC_PORT = i;
            delay_us(100);
        }
        // Falling edge
        for(i = 255; i > 0; i--) {
            DAC_PORT = i;
            delay_us(100);
        }
    }
}

The Realization: Digital systems can perfectly mimic analog behavior. The line between digital and analog blurred before my eyes.

Project 5: Stepper Motor Control - The Dance of Precision

The Ultimate Test: Making a mechanical system respond to digital commands with precision

Motor Specifications:

Unipolar stepper motor
4-phase configuration
1.8 degrees per step (200 steps per revolution)
Driver IC: ULN2003 (Darlington array)

The Step Sequences: Choreography in Code

unsigned char full_step[4] = {
    0x01,   // 0001 - Coil A
    0x02,   // 0010 - Coil B
    0x04,   // 0100 - Coil C
    0x08    // 1000 - Coil D
};

unsigned char half_step[8] = {
    0x01, 0x03, 0x02, 0x06,
    0x04, 0x0C, 0x08, 0x09
};

void rotate_clockwise(unsigned int steps) {
    unsigned char i, j;
    for(i = 0; i < steps; i++) {
        for(j = 0; j < 4; j++) {
            MOTOR_PORT = full_step[j];
            delay_ms(10);   // Speed control
        }
    }
}

void rotate_counterclockwise(unsigned int steps) {
    unsigned char i;
    signed char j;
    for(i = 0; i < steps; i++) {
        for(j = 3; j >= 0; j--) {
            MOTOR_PORT = full_step[j];
            delay_ms(10);
        }
    }
}

void rotate_with_acceleration(unsigned int steps) {
    unsigned int delay_time = 20;   // Start slow
    unsigned char i, j;
    for(i = 0; i < steps; i++) {
        for(j = 0; j < 4; j++) {
            MOTOR_PORT = full_step[j];
            delay_ms(delay_time);
        }
        if(delay_time > 5 && i < steps/3) {
            delay_time--;   // Accelerate
        }
        if(i > 2*steps/3) {
            delay_time++;   // Decelerate
        }
    }
}

The Magic Moment: Writing code that made a physical motor rotate 90 degrees precisely, stop, reverse, and return. The marriage of software and mechanical motion was mesmerizing.

Chapter 4: Hardware Realization - From Bits to Board

The Most Thrilling Phase

The Ultimate Goal: Taking code from my laptop and burning it into actual silicon chips.

The Tool Chain: My Weapons of Choice

Software Arsenal:

Keil µVision IDE - Code editor with compiler and simulator
Proteus Design Suite - Circuit simulation and PCB design
UART Terminal - Serial communication testing

The Programming Process: Burning Code into Silicon

// Final tested code in Keil
#include <reg51.h>

sbit LED = P1^0;

void delay(unsigned int count) {
    unsigned int i, j;
    for(i=0; i<count; i++)
        for(j=0; j<1275; j++);
}

void main() {
    while(1) {
        LED = ~LED;
        delay(500);
    }
}

The Programming Dance

Sequence:

Insert Chip: Place AT89S52 in ZIF socket
Select Device: Choose AT89S52 from programmer software
Load HEX: Browse and load compiled .HEX file
Verify Blank: Check if chip memory is erased
Program: Burn the HEX file to chip memory
Verify: Confirm successful programming
Success: Green light indicates completion

The First Boot: A Moment Frozen in Time

The Checklist:

✅ Power supply connected
✅ Polarity double-checked
✅ All connections verified
✅ External oscillator running
✅ Deep breath taken

I flipped the switch... SUCCESS!

The LCD glowed to life, displaying:

Harshavardhan
ECE Department

That moment: Pure, unfiltered joy. The code I wrote on my laptop was now executing on a physical chip, controlling real hardware. This wasn't simulation. This wasn't theory. This was engineering.

Debug Stories: When Things Don't Work

Problem 1: LCD showing random characters

Cause: Contrast not properly set
Fix: Adjusted 10kΩ potentiometer

Problem 2: Program not executing

Cause: EA (External Access) pin not connected to VCC
Fix: Connected Pin 31 to +5V

Problem 3: Erratic behavior

Cause: Crystal oscillator loose connection
Fix: Soldered connections, added 22pF capacitors

Lesson Learned: Hardware debugging teaches patience and systematic thinking that no simulator can match.

Chapter 5: Advanced Architectures - The Next Frontier

Expanding Horizons

Having mastered 8051, I was ready to explore modern architectures that power today's technology.

ARM Architecture: The Modern Titan

Why ARM Matters:

Powers 95% of smartphones
Dominates IoT and embedded systems
Energy-efficient performance
Scalable from tiny sensors to supercomputers

ARM Philosophy: RISC at Its Finest

Key Principles:

Reduced Instruction Set
- Simple, uniform instructions
- Each instruction executes efficiently
- Load-store architecture
Register-Rich Architecture
- 16 general-purpose registers
- Special registers: SP, LR, PC
- More registers = fewer memory accesses
Pipelining
- Parallel instruction processing

ARM Cortex-M4: My Study Focus

Features:

DSP Instructions with MAC capability
Floating Point Unit (FPU) for advanced math
Nested Vectored Interrupt Controller (NVIC)
Up to 240 interrupt sources

PIC Microcontroller: Another Perspective

PIC16F877A Specifications:

40-pin DIP package
8KB Flash program memory
368 bytes RAM
256 bytes EEPROM
33 I/O pins
8-channel 10-bit ADC

#include <xc.h>

void main() {
    TRISC = 0x00;      // Port C as output
    while(1) {
        PORTC = 0xFF;
        __delay_ms(1000);
        PORTC = 0x00;
        __delay_ms(1000);
    }
}

What Each Architecture Taught Me

8051:

Fundamentals of embedded programming
Importance of timing and delays
Serial communication basics
Interrupt-driven programming

PIC:

Configuration registers are crucial
Built-in peripherals save external components
Different toolchains, different philosophies
EEPROM for non-volatile data storage

ARM:

Modern programming paradigms
RTOS (Real-Time Operating System) concepts
Advanced debugging tools
Industry-standard architecture

Chapter 6: Reflection, Growth & The Road Ahead

The Transformation

January (Start):

Nervous about assembly language
Unsure about hardware connections
Dependent on simulators

July (Now):

Comfortable with multiple architectures
Confident in hardware debugging
Creating real, working projects

Skills Acquired: The Complete Inventory

Technical Skills:

8086 Assembly programming
8051 C and Assembly
Interfacing: LED, LCD, ADC, DAC, Stepper Motor
Timer and interrupt programming
UART serial communication
HEX file generation and microcontroller programming
Debugging hardware circuits
Proteus simulation and Keil microVision usage
Basics of ARM Cortex-M4 and PIC16F877A

Soft Skills:

Patience and perseverance
Problem-solving under pressure
Documentation and reporting
Time management across labs and projects

Projects Portfolio (Highlight Reel)

LED pattern generator using 8051
Name and department display on 16x2 LCD
Temperature monitoring system using LM35 + ADC0804 + 8051 + LCD
Waveform generator (square, triangular, sine) using DAC0808
Stepper motor position control system

Challenges Faced (and Overcome)

Burning late-night oil debugging why the LCD wouldn't display correctly
Resolving erratic behavior due to loose crystal oscillator connections
Learning to read and understand complex datasheets
Adapting to different toolchains (Keil, MPLAB, ARM tools)

Each challenge became a stepping stone instead of a roadblock.

The Road Ahead

This course didn't just teach me processors and controllers—it gave me a mindset:

To think from the hardware up
To respect timing, constraints, and real-world imperfections
To see every bug as a teacher

Next Milestones I'm Aiming For:

Building a complete embedded product prototype
Diving deeper into ARM-based development boards (STM32, etc.)
Learning RTOS and real-time scheduling
Exploring IoT platforms and cloud integration
Contributing to open-source embedded projects

Final Reflection

Six months ago, an LED blink felt like magic.
Today, that magic has a name: engineering.

This journey turned curiosity into capability, theory into tangible projects, and fear into confidence.

If you're standing at the edge of this world, unsure whether to start—take the first step.

The LED blink, the first successful program, the first moving motor—they're all waiting for you on the other side of that decision.

Welcome to the world where bits meet atoms.

Thank You

Thank you for reading my journey. If you're starting or continuing your embedded systems adventure, remember:

Every expert was once a beginner
Debugging is learning
Your curiosity is your superpower

Happy coding and happy soldering! 🔧⚡

Feel free to reach out if you have questions about embedded systems, microcontrollers, or your own learning journey.

My First Open Source Journey

Harshavardhan — Sat, 01 Nov 2025 10:56:51 +0000

Introduction

Starting with open source can feel overwhelming. Where do you begin? What project should you contribute to? How do you make your first pull request? This is the story of my journey from complete beginner to active open source contributor, and I hope it inspires you to start your own journey!

Why I Started with Open Source
Setting Up My First Project: Nextcloud
Understanding and Choosing a License
My First Pull Requests
Contributing to Practice Repositories
Key Lessons Learned
Tips for Future Contributors

Why I Started with Open Source

Open source contribution has always intrigued me. The idea of collaborating with developers worldwide, learning from real-world codebases, and making a tangible impact on software used by millions is incredibly motivating.

My goals were:

Learn industry-standard development practices
Connect with the developer community
Build a portfolio of real contributions
Understand collaborative software development
Gain practical experience beyond tutorials

Setting Up My First Project: Nextcloud

Why Nextcloud?

I chose Nextcloud as my first major project because:

Well-documented - Excellent documentation for new contributors
Active community - Responsive maintainers and helpful community
Real-world impact - Used by millions for file storage and collaboration
Modern tech stack - PHP, JavaScript, Vue.js
Beginner-friendly issues - Tagged issues for first-time contributors

Setting Up the Development Environment

Challenges I Faced

Challenge 1: Large Codebase

Problem: Nextcloud is a massive project with thousands of files
Solution: Started by reading the CONTRIBUTING.md file and focused on one module at a time

Challenge 2: Development Environment

# Clone the repository
git clone https://github.com/nextcloud/server.git
cd server
# Install dependencies
composer install
npm install
# Set up local development server
php -S localhost:8080

Problem: Setting up all dependencies was complex
Solution: Used Docker containers to simplify the setup process

Challenge 3: Understanding the Architecture

Problem: Didn't know where to start making changes
Solution: Read existing PRs and issues to understand common patterns

Understanding and Choosing a License

One crucial aspect of my project was understanding open source licenses. This was eye-opening!

Why Licenses Matter

A license:

Protects your work
Defines how others can use your code
Clarifies contribution terms
Prevents legal issues

Licenses I Considered

License	Pros	Cons	Best For
MIT	Simple, permissive, widely used	Minimal protection	Most projects
GPL v3	Strong copyleft, ensures freedom	Restrictive for commercial use	Community-focused projects
Apache 2.0	Patent protection, permissive	More complex	Corporate-backed projects
BSD	Very permissive	Minimal contributor protection	Academic projects

My Choice: MIT License

I chose the MIT License for my project because:

Simplicity - Easy to understand for contributors
Flexibility - Allows both open source and commercial use
Wide adoption - Most developers are familiar with it
Minimal restrictions - Encourages maximum collaboration

Pro Tip: Add a LICENSE file to your repository root. GitHub will automatically detect it!

My First Pull Requests

PR #1: Documentation Fix (MERGED ✓)

Repository: Nextcloud Documentation
Issue: Outdated installation instructions
Changes: Updated PHP version requirements and fixed broken links

What I learned:

Always reference the issue number
Test all links before submitting
Clear commit messages are crucial

PR #2: Bug Fix in User Management (MERGED ✓)

Repository: Nextcloud Server
Issue: User search not working with special characters
Changes: Added proper escaping for search queries

// Before
$query = "SELECT * FROM users WHERE username LIKE '%$search%'";
// After
$query = $this->db->prepare(
    "SELECT * FROM users WHERE username LIKE :search"
);
$query->execute(['search' => '%' . $this->db->escape($search) . '%']);

What I learned:

Security matters - always sanitize inputs
Write tests for your changes
Follow the project's coding standards

PR #3: UI Enhancement (UNDER REVIEW 👀)

Repository: Nextcloud Server
Issue: Improve accessibility of file sharing dialog
Changes: Added ARIA labels and keyboard navigation

What I learned:

Patience is key - reviews take time
Be open to feedback and suggestions
Iterate based on maintainer comments

Contributing to Practice Repositories

To build confidence, I also contributed to beginner-friendly practice repositories:

1. first-contributions

Task: Add my name to contributors list
Status: MERGED ✓
Time to merge: 2 days
Takeaway: Perfect for learning the fork-clone-PR workflow!

2. HyunCafe/contribute-practice

Task: Add name and inspirational quote
Status: MERGED ✓
Time to merge: 3 days
Takeaway: Great for understanding markdown formatting and git basics.

3. EddieHubCommunity/hacktoberfest-practice

Task: Add GitHub profile to community list
Status: MERGED ✓
Time to merge: 1 day
Takeaway: Active community with fast review cycles - highly recommended!

Key Lessons Learned

1. Read CONTRIBUTING.md First

Every project has guidelines. Reading them saves time and shows respect to maintainers.

2. Start Small

My first PRs were:

Documentation fixes
Typo corrections
Adding comments
Small bug fixes

Don't try to refactor the entire codebase on day one!

3. Communication is Key

Before working on an issue:

Comment on the issue expressing interest
Ask for clarification if needed
Propose your approach
Wait for maintainer approval
Then start coding

4. Write Clean Commits

Bad commit:

git commit -m "fixed stuff"

Good commit:

git commit -m "fix: Resolve user search issue with special characters
- Added proper input sanitization
- Updated tests for edge cases
- Fixed SQL injection vulnerability
Fixes: #12345"

5. Be Patient with Reviews

Timeline	What to Expect
0-2 days	Automated checks run
2-7 days	Initial maintainer review
1-2 weeks	Back-and-forth on changes
2-4 weeks	Final approval and merge

Remember: Maintainers are volunteers with day jobs!

6. Handle Rejection Gracefully

Not all PRs get merged, and that's okay!
When your PR is rejected:

Thank the reviewer for their time
Ask for feedback on what to improve
Learn from the experience
Move on to the next contribution

7. Test Everything

Before submitting:

# Run tests
npm test
# Check code style
npm run lint
# Build the project
npm run build
# Test manually in browser

Tips for Future Contributors

Getting Started Checklist

[ ] Create a GitHub account
[ ] Set up Git on your computer
[ ] Learn basic Git commands (clone, branch, commit, push, PR)
[ ] Find beginner-friendly projects
[ ] Read project documentation
[ ] Join project communities (Discord, Slack, Forums)
[ ] Start with "good first issue" labels
[ ] Make your first contribution
[ ] Celebrate!

Finding Projects to Contribute To

Websites:

Good First Issue
First Timers Only
Up For Grabs
CodeTriage

GitHub Search:

label:"good first issue" is:open is:issue language:JavaScript

Essential Git Commands

# Fork and clone
git clone https://github.com/YOUR_USERNAME/project.git
cd project
# Create a branch
git checkout -b fix-issue-123
# Stage and commit changes
git add .
git commit -m "fix: description of fix"
# Push to your fork
git push origin fix-issue-123
# Update your fork with upstream changes
git remote add upstream https://github.com/ORIGINAL_OWNER/project.git
git fetch upstream
git merge upstream/main

Writing Good PRs

Template:

## Description
Brief description of what this PR does

## Related Issue
Fixes #123

## Changes Made
- Change 1
- Change 2
- Change 3

## Testing
- [ ] Tested locally
- [ ] Added unit tests
- [ ] Updated documentation

## Screenshots (if applicable)

![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q2dj7v3v4s6ix2z0uz57.png)

## Checklist
- [ ] Code follows project style guidelines
- [ ] Self-review of code completed
- [ ] Commented complex code sections
- [ ] Updated documentation
- [ ] No breaking changes

My Statistics After 3 Months

Metric	Count
Repositories contributed to	8
Pull requests submitted	15
Pull requests merged	12
Issues opened	5
Comments on discussions	47
Stars received	23

What's Next?

My journey is just beginning! Here's what I'm planning:

Contribute to larger projects - Dive deeper into complex issues
Become a maintainer - Help review others' PRs
Create my own OSS project - Give back to the community
Mentor new contributors - Share what I've learned
Participate in GSoC - Apply for Google Summer of Code

Final Thoughts

Open source contribution has been one of the most rewarding experiences of my developer journey. It's not just about code – it's about:

Community - Meeting amazing developers worldwide
Learning - Exposure to real-world codebases
Impact - Contributing to software used by millions
Career - Building a portfolio that speaks for itself
Growth - Becoming a better developer every day

If you're thinking about starting – just do it! Your first contribution doesn't have to be perfect. The community is welcoming, and everyone started where you are now.

Useful Resources

GitHub Open Source Guide
How to Contribute to Open Source
First Contributions
The Beginner's Guide to Contributing to Open Source
Nextcloud Developer Documentation

Let's Connect!

I'd love to hear about your open source journey!

GitHub: @Born-as-Harsha
Twitter: @harshaabhi
LinkedIn: @harshaabhi

Have questions? Drop a comment below, and I'll be happy to help!

Summary

Key Takeaways:

Start with documentation and small fixes
Choose projects that interest you
Read and follow contribution guidelines
Be patient with the review process
Learn from feedback and keep improving
Give back to the community

Your turn: What's stopping you from making your first contribution? Let me know in the comments!

Thank you for reading! If you found this helpful, please share and follow me for more content about open source, web development, and my coding journey!

OpenSource #GitHub #Beginners #WebDevelopment #CodingJourney #FirstContribution #Nextcloud #DevCommunity

DEV Community: Harshavardhan

Six Months of Growth: My B.Tech Journey Through Python, AI, Full Stack Development & ECE

Introduction

Table of Contents

Course Overview

Global Logic Building Contest Practicum

What It Was

What I Learned

Key Takeaway

Coding Skills Training - Algorithms

Focus Areas

Sample Code: Sliding Window Pattern

Challenges I Faced

Python Full Stack Development

Tech Stack Covered

What I Built

Why It Matters

AI & ML Using Python (Industrial Automation)

Course Focus

Topics Covered

Code Snippet: Building a Classifier

Industrial Automation Insight

Machine Learning with Python Programming

What Made This Different

Key Concepts Mastered

My Biggest Challenge

VLSI Design & Digital VLSI Design

What Is VLSI?

What I Learned

Code Example: Verilog D Flip-Flop

Why It Matters

Electromagnetic Waves & Transmission Lines

Course Overview

Key Concepts

Real-World Application

Digital Communication

What I Studied

Topics Covered

Code Example: BPSK Modulation Simulation

Network Protocols & Security

Course Highlights

Key Protocols Studied

Security Concepts

Volleyball - Beyond the Classroom

Why It Matters

Key Lessons Learned

1. Multidisciplinary Knowledge Is Power

2. Consistency Beats Intensity

3. Connect Theory with Practice

4. Community Matters

What's Next?

Let's Connect!

Summary

The Path Toward Embedded Systems Expertise

A Chronicle of Passion, Perseverance, and Processors

The Beginning: A Spark of Curiosity

Table of Contents

Chapter 1: The 8086 Foundation - Where Legends Begin

Learning to Think Like a Machine

Architecture: The Blueprint of Intelligence

The Register Set: Your Programming Palette

Memory Segmentation: The 1MB Puzzle

My First Programs: Baby Steps to Giant Leaps

Key Takeaways from Phase 1

Chapter 2: Enter the 8051 - When Code Meets Reality

From Virtual to Physical

The 8051 Architecture: A Masterpiece of Integration

The Pin Configuration: Gateway to the Physical World

Programming Paradigm Shift

The First Blink

Timers: The Heartbeat of Embedded Systems

Chapter 3: The Interfacing Chronicles - Bringing Projects to Life

Where Theory Becomes Tangible

Project 1: LED Interfacing - Hello, Physical World!

Project 2: LCD Interface - My Digital Canvas

The LCD Dance: Initialization Sequence

Project 3: ADC Interface - Reading the Analog World

Real-World Application: Temperature Monitoring

Project 4: DAC Interface - Creating Analog from Digital

Waveform Generation