DEV Community: Mayowa Arokoola

Understanding JVM, JRE, and JDK: A Complete Guide

Mayowa Arokoola — Tue, 19 Aug 2025 11:57:35 +0000

As a Java developer, you’ll encounter these three acronyms constantly: JVM, JRE, and JDK. Understanding what they are, what they do, and how they work together is fundamental to Java development. Let’s break them down systematically.

The Hierarchy: How They Fit Together
Before diving into details, it’s important to understand the relationship:

JDK (Java Development Kit)
├── JRE (Java Runtime Environment)
└── JVM (Java Virtual Machine)
The JDK contains the JRE, which contains the JVM. Each layer builds upon the previous one, adding more functionality.

JVM — Java Virtual Machine
The JVM is the execution engine that runs your Java programs.

What it does:
Executes bytecode: Loads compiled .class files and runs your program
Platform independence: Makes your Java code “write once, run anywhere” by abstracting away OS differences
Memory management: Handles automatic garbage collection to free up unused memory
Multi-threading*: Manages concurrent execution when your program uses multiple threads

Security: Performs built-in security checks to protect the system

Key point:
The JVM takes your compiled Java bytecode, combines it with necessary standard library classes, loads everything into memory, and executes your program seamlessly across Windows, Linux, macOS, or any other supported platform.

JRE — Java Runtime Environment
Everything you need to run Java programs (but not develop them).

What it includes:
The JVM (as described above)
Java Standard Library: A comprehensive collection of pre-built classes and utilities:
java.lang - Core classes like String, Math, Exception, Object
java.util - Collections (Lists, Sets, Maps) and utilities
java.io - Input/output operations
java.sql - Database connectivity
Many other essential packages

When to use:
If you only need to run Java applications and never plan to write or compile Java code, installing just the JRE is sufficient.

JDK — Java Development Kit
The complete toolkit for Java development, everything you need to create, modify, compile, debug, test, and run Java programs.

What it includes:

Everything from JRE, plus:
javac: The Java compiler that converts .java files into .class bytecode files

Debugger: Tools for step-by-step code execution and troubleshooting

Development tools:

JConsole and other monitoring utilities
JAR file creation and management tools
Documentation generators
Profiling tools

Source code: Access to the actual source code of Java standard libraries

Whether you’re just starting with Java or need a refresher, remember: JVM executes, JRE provides the runtime environment, and JDK gives you the whole development experience.

Programming Fundamentals: What Every Beginner Must Know Before Coding

Mayowa Arokoola — Sun, 10 Aug 2025 12:10:31 +0000

Many aspiring programmers make a common mistake: they jump straight into complex code without understanding the fundamentals. This approach often leads to confusion and gaps in knowledge. If you want to succeed in IT and adapt to different programming languages as the industry evolves, you need a solid foundation in programming and computer basics.

Let me walk you through these fundamentals in a way that makes sense.

Understanding Your Computer
When you think about a computer, you probably picture components like the CPU, monitor, RAM, hard drive, keyboard, and mouse. Today’s computers come in many forms — your smartphone, laptop, and desktop are all computers. But the most crucial component in all of them is the processor (Central Processing Unit or CPU).

The processor is like the brain of your computer. Whether you’re streaming music, making a phone call, or running an app, the processor handles all these tasks. Here’s what makes it special:

How Processors Work
Processors are built using semiconductor technology, specifically using tiny switches called transistors. Modern processors contain billions of these microscopic transistors that can switch between two states:

OFF (representing 0)
ON (representing 1)
This creates what we call binary — a system using only 0s and 1s. Everything your computer does ultimately comes down to these simple on/off signals.

The Language Challenge
Here’s where it gets interesting. Your processor is incredibly powerful, but it only “speaks” one language: binary (those 0s and 1s). However, humans don’t naturally think in binary. Imagine trying to write a complex program using only combinations like 01001000 01100101 01101100 01101100 01101111!

This created a communication problem that the computing world solved through evolution.

The Evolution of Programming Languages

1. Machine Language (1940s)
This is pure binary — writing instructions directly in 0s and 1s. While processors understand this perfectly, it’s nearly impossible for humans to work with for complex programs.

Example: 10110000 01100001 (this actually means "move the value 97 into a register")

2. Assembly Language (1950s)
Smart engineers created mnemonics — human-friendly abbreviations for common operations:

ADD for addition
SUB for subtraction
MOV for moving data
JMP for jumping to different parts of code
This was much easier for humans, but processors still couldn’t understand it directly. So they created assemblers — special programs that translate assembly language into machine language.

3. High-Level Languages (1950s-1960s)
The next breakthrough came with languages that use English-like commands and mathematical symbols:

print("Hello World")
if (age > 18)
total = price + tax
Languages like FORTRAN (1957) and COBOL (1959) pioneered this approach. These are much more intuitive for humans, but again, processors can’t understand them directly.

The Translation Process
This is where compilers and interpreters come in. These are sophisticated programs that:

Take your human-readable code
Check it for errors
Translate it into machine language
Deliver instructions the processor can execute
Think of them as expert translators converting your English-like instructions into the processor’s native binary language.

Why This Foundation Matters
Understanding this progression helps you grasp several key concepts:

All programming languages eventually become machine language
Different languages are just different ways to communicate the same fundamental concepts
Learning principles transfers between languages more easily than memorizing syntax
Problem-solving skills matter more than knowing specific commands
Moving Forward
With this foundation, you’re better equipped to:

Learn any programming language more effectively
Understand why certain programming concepts exist
Debug problems by thinking about what’s happening “under the hood”
Adapt as new technologies and languages emerge
Remember: programming languages are tools. The real skill is learning to think logically and break down problems into steps a computer can follow. Master these fundamentals, and you’ll find that picking up new languages becomes much more manageable.

How Java Works: A Complete Guide

Mayowa Arokoola — Sat, 12 Jul 2025 10:43:47 +0000

Understanding how Java programs execute is fundamental to becoming an effective Java developer. This guide walks you through the entire process from writing code to execution, explaining the key components that make Java’s “write once, run anywhere” philosophy possible.

The Java Virtual Machine (JVM): The Heart of Java
The JVM is what makes Java special. It acts as an intermediary between your Java code and the operating system, enabling Java’s platform independence. Here’s what you need to know:

Platform Independence: While your Java source code can run on any system, each operating system requires its own specific JVM implementation. This means Java achieves platform independence at the source code level, but remains platform-dependent at the binary level.

Execution Engine: The JVM doesn’t run your original Java code directly. Instead, it executes bytecode — a platform-neutral intermediate representation of your program.

The Java Program Lifecycle
Every Java program follows a predictable journey from source code to execution:

Writing the Code
You write Java code using human-readable syntax in .java files. All executable code must be placed within methods, with the main method serving as your program's entry point.
Compilation Phase
The Java compiler (javac) transforms your source code into bytecode:
Input: .java files containing your source code
Output: .class files containing platform-neutral bytecode
Purpose of this compilation step: Creates an intermediate representation that any JVM can understand
Execution Phase
The JVM takes over and executes your bytecode:
Loads the .class files
Searches for the main method as the starting point
Executes your program instruction by instruction
The Main Method: Your Program’s Gateway
Every Java application needs a main method with this exact signature:

Why this signature matters:

public: Accessible from anywhere (the JVM needs to call it)

static: Can be called without creating an object instance

void: Doesn't return a value

String[] args: Accepts command-line arguments

Complete Example
Here's a simple but complete Java program:

To run this program:

Save as Hello.java

Compile: javac Hello.java (creates Hello.class)

Execute: java Hello (note: no .class extension needed)

Understanding the Java Runtime Environment (JRE)
The JRE provides everything needed to run Java programs. Think of it as a complete runtime ecosystem:

Kitchen Analogy:

The JRE is like a fully equipped kitchen with all necessary tools and ingredients

The JVM is the oven that actually cooks your meal (executes your code)

The libraries and APIs are like the utensils and ingredients that make cooking possible

What the JRE includes:

The JVM itself

Core libraries (like java.lang, java.util)

Supporting files and resources

Runtime tools and utilities

Java Architecture: The Big Picture
Understanding how Java components fit together helps clarify the development process:

Java Development Kit (JDK)
The complete development environment containing:

Compiler (javac): Converts source code to bytecode

JRE: Everything needed to run Java programs

Development tools: Debugger, documentation generator, etc.

Java Runtime Environment (JRE)
The runtime environment containing:

JVM: The execution engine

Libraries: Pre-built code for common tasks

Supporting files: Configuration and resource files

Java Virtual Machine (JVM)
The core execution engine that:

Interprets bytecode: Translates bytecode into machine-specific instructions

Manages memory: Handles object creation and garbage collection

Provides security: Enforces Java's security model

Key Principles for Java Development
Object-Oriented Foundation: Everything in Java is an object or belongs to a class. Classes serve as blueprints that define the structure and behavior of objects.

Write Once, Run Anywhere: Thanks to the JVM, your compiled Java code can run on any platform with a compatible JVM installation.

Bytecode Advantage: The intermediate bytecode format allows for platform independence while maintaining performance through JVM optimizations.

Best Practices
Always include a main method in classes you want to execute directly

Follow naming conventions: Class names should match file names

Organize code logically: Use packages to group related classes

Handle exceptions properly: Java's exception handling keeps programs robust

Understand the compilation process: This helps debug issues and optimize performance

Understanding these fundamentals gives you a solid foundation for Java development. The JVM's role as an intermediary, the compilation process, and the runtime environment all work together to make Java a powerful and portable programming language.

Complete Guide to Becoming a Backend Developer.

Mayowa Arokoola — Thu, 03 Jul 2025 23:37:43 +0000

Becoming a backend developer requires mastering five essential skills. This comprehensive guide will walk you through each skill, providing timelines and practical advice to help you land your first backend development job within 12 months.

Master a Programming Language (2 months)

Choose Your Language Wisely
The first step in backend development is selecting a programming language. Popular options include:

JavaScript — Ideal for full-stack development
Python — Perfect for rapid prototyping and beginner-friendly syntax
Ruby — Great for fast development cycles
Java — Preferred for large-scale enterprise applications
C# — Heavily used in enterprise and government systems
Go — Excellent for performance-critical applications

Which Language Should You Pick?

There’s no “best” language — the choice depends on project requirements, team expertise, and performance needs. However, for beginners, here are my recommendations:

Python (Top choice) — Easiest to learn with simple, readable syntax
Java (Second choice) — Solid language taught in computer science programs
JavaScript (Third choice) — Has quirks from its history, but widely used

Common Mistake to Avoid

Don’t try to learn multiple languages simultaneously. Focus on one language and its ecosystem of tools and libraries. Research job opportunities in your area for your chosen language — Python, Java, and JavaScript typically have the most openings.

Timeline
Dedicate 2 months to learning your chosen language, studying 3–5 hours daily.

Learn Version Control with Git (1–2 weeks)

Why Git Matters
Git is an essential tool for tracking code changes and collaborating with other developers. While Git has numerous features, you’ll use only about 20% of them 80% of the time.

What You Need to Know
Basic Git commands
Working with GitHub repositories
Version control fundamentals
Collaboration workflows

Timeline
1–2 weeks of focused practice is sufficient to get up and running.

Study Data Structures and Algorithms (1–2 months) Why This Step Is Critical Many self-taught programmers skip this fundamental step, but it’s crucial for:

Building efficient backend systems
Passing technical interviews at major companies
Understanding complex problem-solving approaches
What to Study
Focus on classic computer science concepts:

Common data structures (arrays, linked lists, trees, graphs)
Essential algorithms (sorting, searching, traversal)
Time and space complexity analysis
Problem-solving patterns
Timeline
Spend 1–2 months studying these fundamentals. This investment will pay dividends throughout your career.

Learn Design Patterns (2 months) Understanding Design Patterns Design patterns are proven solutions to common software design problems. The classic “Gang of Four” book documents 23 essential patterns used throughout modern web frameworks like Spring, Django, and ASP.NET Core.

Why Design Patterns Matter
Learning design patterns will give you:

Deeper understanding of object-oriented design principles
Insight into how frameworks work under the hood
Better problem-solving approaches for common challenges
Getting Started
While the original “Design Patterns” book is comprehensive, it’s written in C++ with outdated examples. Look for modern resources that use contemporary examples in your chosen language.

Timeline
With consistent daily practice, you can gain solid understanding in about 2 months.

Master Database Technologies (2 months total) Relational Databases (1 month) Relational databases store data in tables with rows and columns. They’re ideal for:

Banking systems
E-commerce applications
Any system requiring complex queries and transactions
Popular Options:

MySQL (recommended for beginners)
PostgreSQL
SQL Server
Oracle
What to Learn:

SQL (Structured Query Language)
Database design principles
Query optimization basics
NoSQL Databases (1 month)
NoSQL databases offer flexible data models without predefined table structures. They’re perfect for:

Applications requiring flexible data models
Real-time analytics
Rapid development cycles
Popular Options:

MongoDB (recommended for beginners)
CouchDB
Cassandra
Timeline
One month each for relational and NoSQL databases provides solid practical knowledge.

Learn a Web Framework (2 months) Framework Selection by Language Choose your framework based on your programming language:

Python → Django
Java → Spring Boot
JavaScript → Express.js
C# → ASP.NET Core
Ruby → Ruby on Rails
Go → Gin
What Frameworks Provide
All these frameworks offer similar core functionality:

Request and response handling
Database interaction
Security features
API development tools
Routing capabilities
Building APIs
With these frameworks, you’ll build Application Programming Interfaces (APIs) that serve as communication bridges between front-end and back-end systems.

Timeline
With solid programming and database knowledge, you can learn any framework in about 2 months.

Your 12-Month Roadmap
Following this structured approach with consistent daily practice (3–5 hours), you’ll be ready to apply for entry-level backend developer positions within 12 months:

Months 1–2: Master your chosen programming language
Weeks 3–4: Learn Git and version control
Months 3–4: Study data structures and algorithms
Months 5–6: Learn design patterns
Months 7–8: Master database technologies
Months 9–10: Learn your chosen web framework
Months 11–12: Build projects and prepare for interviews

Key Success Tips

Focus on depth over breadth — Master one language thoroughly rather than learning many superficially
Practice consistently — Daily coding practice is more effective than sporadic intense sessions
Build projects — Apply your knowledge through hands-on development
Research your local job market — Understand which technologies are in demand in your area
Don’t skip the fundamentals — Data structures and algorithms knowledge will serve you throughout your career
Next Steps
Once you’ve mastered these five essential skills, you’ll have a strong foundation for backend development. There are additional advanced topics you can explore to further enhance your skills, but these five areas will provide everything you need to start your backend development career.

Remember, becoming a skilled backend developer is a journey that requires patience, persistence, and continuous learning. Stay focused on one skill at a time, practice regularly, and you’ll be well on your way to landing your first backend development role.

Understanding Web Development: How Websites Work

Mayowa Arokoola — Sat, 14 Jun 2025 10:45:22 +0000

What Happens When You Visit a Website?
Have you ever wondered what actually happens when you type “amazon.com” into your browser and press Enter? The process is surprisingly similar to making a phone call to a friend, and understanding this analogy will help you grasp the fundamentals of web development.

The Phone Call Analogy
Making a Phone Call
When you want to talk to a friend, you:

Pick up your phone
Dial their number
Wait for them to answer
Start a conversation
Listen to their response
Continue the back-and-forth dialogue
Visiting a Website
Browsing the web follows the same pattern:

Open your browser (your “phone”)
Enter a website address (the “phone number”)
Send a request to the website’s server
Wait for the server to respond
Receive the website content
View and interact with the page
The Technical Process Behind Web Browsing

Step 1: Entering the URL

When you type an address like “amazon.com” into your browser’s address bar, you’re entering what’s called a URL (Uniform Resource Locator). This is the web equivalent of a phone number — it tells your browser exactly where to find the website you want to visit.

Step 2: Sending the Request
Your browser then sends a request to a remote computer somewhere on the internet. This computer belongs to the company that owns the website (Amazon, in our example).

This communication follows a standardized protocol called HTTP (Hypertext Transfer Protocol) or HTTPS (HTTP Secure) when the connection is encrypted. You’ll notice URLs often start with “http://” or “https://” — your browser typically adds this automatically.

Step 3: The Server Responds
The remote computer receiving your request is called a server. On this server, web developers have written code that contains instructions for:

What content to display
How the website should look
How it should behave
The server processes your request and sends back the appropriate website code as a response.

Step 4: Your Browser Displays the Website
Your browser receives this code and interprets the instructions, transforming them into the visual website you see on your screen. This entire process — from clicking Enter to seeing the fully loaded page — typically takes just milliseconds.

Understanding Frontend vs Backend
Frontend (Client-Side)
The frontend or client-side refers to:

Your browser (Chrome, Firefox, Safari, etc.)
You, the user
Everything you see and interact with on the website
The user interface and user experience
Backend (Server-Side)
The backend or server-side includes:

The remote computer hosting the website
The server software and databases
The code that processes requests and generates responses
Everything that happens “behind the scenes”
The Request-Response Cycle
This fundamental process of web communication is called the request-response cycle:

Request: Your browser asks the server for a specific webpage
Processing: The server finds and prepares the requested content
Response: The server sends the website code back to your browser
Rendering: Your browser displays the website on your screen
Why This Matters for Web Development
Understanding this process is crucial because web developers work on both sides of this conversation:

Frontend developers create the code that runs in your browser, focusing on user interfaces and user experiences
Backend developers build the server-side systems that process requests and manage data
Full-stack developers work on both the frontend and backend
Key Takeaways
Web browsing is essentially a conversation between your browser and a remote server
Every website visit involves a request from your browser and a response from the server
URLs are like phone numbers — they tell your browser where to find websites
HTTP/HTTPS protocols ensure browsers and servers can communicate effectively
The entire process happens in milliseconds, making web browsing feel instantaneous
This request-response model forms the foundation of all web development, whether you’re building a simple blog or a complex e-commerce platform like Amazon. Understanding this fundamental concept will help you make sense of more advanced web development topics as you continue learning.