DEV Community: Nabil Mahmud

Java Newbie to Pro? Day 3 – Who is Who and What They Do in my First Java Program

Nabil Mahmud — Thu, 06 Feb 2025 14:26:30 +0000

In Day 2, I created my first program and ran it to print the phrase "Hello there!" to the console. Today, I’ll be sharing my understanding of that first program—breaking down who is who and what they do in our Java code.

👇 This was my first Java program:

public class MySweetProgram {
   public static void main(String[] args) {
      System.out.println("Hello there!");
   }
}

🏗️ The Blueprint aka Class

public class MySweetProgram

Every program is wrapped inside a class. Here, MySweetProgram is our class. It has an opening and closing curly brace, and it acts as a container for our code.

📌 Remember: The class name must match the filename. That’s why our file is named MySweetProgram.java.

❤️ The Heart of the Program

public static void main(String[] args)

The heart (or should I say 心 Xīn?) of the program! Gotta sneak in some Chinese practice while I’m at it. 😆

This is the entry point of every Java program. When you run the code, Java starts executing from the main method. Let’s break it down:

public – This means the method can be accessed from anywhere.
static – It belongs to the class itself, so we don’t need to create an object to run it.
void – This means the method doesn’t return any value.
main – The special method name that Java looks for when running the program.
String[] args – This is used to accept command-line arguments (not something we need right now, but useful for later!).

🖨️ Printing to the Console

System.out.println("Hello there!");

This line prints "Hello there!" to the console. It’s a simple statement that outputs the text passed to the println() method. However, we need not worry about the System.out part at this moment.

That’s it for today!

Java Newbie to Pro? Day 2 – How I Create My First Java Program

Nabil Mahmud — Wed, 05 Feb 2025 04:04:15 +0000

If you read my previous post, you know that Day 1 was all about setting up my Java development environment. Now that everything is ready, it’s time to write some actual Java code! 🚀

To save myself some keystrokes (and give you a more visual guide), I’ll be using video clips from Caleb Curry’s Java tutorial—because, let’s be honest, watching something is sometimes way easier than reading long explanations! 😁

Creating a New Java Project in Eclipse

I followed the steps in this video clip to create a new Java project using Eclipse. Since the clip is from Caleb's original tutorial, I had to make a few small tweaks because Eclipse’s default project setup has changed slightly over time. But here’s a challenge for you—try figuring out the tweaks yourself! A little bit of problem-solving will add to your technical sophistication and serve you well on your programming journey. 😉

Creating the First Java Program

I followed the steps in this clip to create my very first Java program—smooth sailing, no hiccups! The process involves creating a Java class using the IDE. In Java, the class name must match the filename that contains it. So, in this case, I created a file named MySweetProgram.java, which holds a class with the same name: MySweetProgram.

In the next post, I'll give a brief and superficial introduction to classes. For now, just think of a class as a container that holds different pieces of your program.

Tweak and Run the First Java Program

After setting up the program following the clip above, I used this clip to tweak the code and finally run it—successfully printing the phrase "Hello there!" to the console. Btw,these are the lines of our first program:

public class MySweetProgram {
   public static void main(String[] args) {
      System.out.println("Hello there!");
   }
}

👉 "In the next post, we’ll learn more about the nitty-gritty of the program we've just finished writing.

Java Newbie to Pro? Day 1 – How I Set Up My Java Dev Environment

Nabil Mahmud — Mon, 03 Feb 2025 07:19:58 +0000

In this post, I’ll walk you through how I set up my Java development environment on my primary (and only) machine—a Dell Latitude running Ubuntu.

Setting Up the Development Environment

1. Downloading and Extracting the JDK

First, I downloaded the latest stable JDK. To be more specific, I went with JDK 21's x64 Compressed Archive option.

After a little while, the JDK archive stuff got downloaded into my pc's Downloads directory. Following the download, I extracted the contents of the archive into the Home directory using the following command:

tar -xvf Downloads/jdk-21_linux-x64_bin.tar.gz -C ~

By default, this created a new folder named jdk-21.0.6 (the directory name could be different for you as it depends on the version of the JDK you downloaded initially). To keep things neat and have a consistent directory name, I did the following:

Created a new directory named jdk-21:

mkdir ~/jdk-21

Moved all the extracted contents into this new directory:

mv ~/jdk-21.0.6/* ~/jdk-21/

Finally, I removed the now-empty jdk-21.0.6 folder:

rmdir ~/jdk-21.0.6

At this point, I had my JDK neatly placed inside ~/jdk-21.

2. Setting Up the Environment Variables

To ensure that my system could recognize Java commands globally, I had to set up environment variables. Here’s how I did it:

Opened the bashrc file for editing using Nano:

nano ~/.bashrc

Scrolled to the bottom and added the following lines:

# Java
export JAVA_HOME="/home/nabil/jdk-21"
export PATH=$PATH:$JAVA_HOME/bin

Saved the file (CTRL + X, then Y, then Enter). Applied the changes immediately by running:

source ~/.bashrc

To verify that Java was installed and accessible, I ran:

java --version

It successfully displayed the installed Java version! 🎉

3. Installing Eclipse IDE

Since Caleb uses Eclipse IDE in his tutorial, I decided to install it for consistency. I installed Eclipse from Ubuntu's App Center.

4. Creating My First Java Project

With Eclipse up and running, I created a new Java project to test everything:

Clicked on File → New → Java Project.
Named the project hello.
Clicked Finish to create the project.
And that’s it! My Java development environment was fully set up and ready to go.

P.S. If you think my explanation sucks(it actually does😆), then you should be following this guide from dev.java which is really awesome, by the way!

Here's the link to day 2 of my Java Journey😉

Java Newbie to Pro? My Java Learning Diary – Follow Along!

Nabil Mahmud — Sun, 02 Feb 2025 13:22:24 +0000

For the past two years, I’ve been bouncing between languages and frameworks—JavaScript, Ruby, Dart, React, Flutter, React Native, Ruby on Rails—you name it. Some call it procrastination (I prefer "thorough research"), but after all that exploring, I’ve finally made up my mind. This time, I’m committing to Java like never before.

Why Java? Let’s be honest—endless research (read: procrastination) burned me out. And I need to get a job, right? No one is hiring a “full-stack everything” guy. It’s time to specialize. While learning Dart for Flutter, I became fascinated with Object-Oriented Programming (OOP). That interest never faded, and since Java is a OOP language, I figured out now’s the perfect time to dive in and level up my skills!

I'm following this tutorial, and Caleb's teaching style is awesome, by the way!

After exploring different resources, I found dev.java's Learn Java tutorials and Caleb Curry’s Java tutorials particularly insightful and worth following. In this blog series, I’ll document my journey of learning Java from these resources—sharing key takeaways, challenges, and insights along the way.
Hope you'll be with me and help me with your two cents. Without further ado LET'S JUMP IN!

Day-1: setting up development environment.

Dart 101: A Pure Function

Nabil Mahmud — Mon, 14 Oct 2024 04:17:38 +0000

A very brief intro:

Before getting to know what a pure function is we had better learn about side effects. If a function prints anything to the console or changes any value outside of its own block then it is having side effects. To put it simply, it is having effect outside of its own tiny world i.e. the area defined by two curly braces.

This is one example of a function having a side effect:

void shoutOutLoud(String message) {
  print(message);
}

This is yet another example of a function having a side effect:

int villagePopulation = 50000;
String shoutOutLoud(String message) {
  villagePopulation = 1;
  return message;
}

A pure function:

A function that takes its inputs and only returns its output without affecting any other stuff in a program is called a pure function. In a word a function that do not impose any side effects is a pure function.

Following is an example of a pure function:

String shoutOutLoud(String message) {
  return message;
}

The above mentioned function shall only return the message which is of string type. It will not affect anything outside of it or print anything to the screen.

Dart 101: Parameter vs Argument

Nabil Mahmud — Sun, 13 Oct 2024 15:49:36 +0000

Parameter

A parameter is a placeholder for a function's potential input value. At the time of declaring a function its parameter/parameters is/are inscribed within its parentheses. If a function needs multiple parameters for multiple input values, the parameters need to be comma separated.

In the following code block we have declared a function named getFullName. Here, firstName and lastName are the parameters of getFullName function.

String getFullName(String firstName, String lastName) {
  return "Full Name: $firstName $lastName";
}

Argument

An argument is the actual input which is passed down to a function when the function is called, and in that case the argument replaces the parameter.

In the following code block we have called the getFullName function and assigned its return value to myFullName variable. Here, myFirstName and mySecondName are arguments of the getFullName function.

void main() {
  const myFirstName = "Nabil";
  const mySecondName = "Mahmud";
  final myFullName = getFullName(myFirstName, mySecondName);
  print(myFullName);
}

N.B. A parameter is an abstract or virtual thing, but an argument is a concrete or actual thing.