DEV Community

Divya Darshana
Divya Darshana

Posted on

How I Learned to Stop Worrying and Love the 50-Step 'Hello World' Setup

(Or: "Why Your Go Binary Compiles Faster Than Java's IDE Opens")

Author’s Note

Hi! I'm a caffeine-powered Go open-source maintainer. My hobbies include:

  1. Writing code that compiles in 0.3 seconds 🚀
  2. Begging humans to fix GitHub issues 😭
  3. Staring at Java's AbstractFactoryProxyBean until I weep 💔

Want to help? Star ⭐/contribute to github.com/gofr-dev/gofr!

(No Java knowledge required - we promise!)

1. Installing JDK: Downloading the Universe 🌌

What is JDK?

The Java Development Kit is like if Go's compiler went to business school and came back with an MBA, a mortgage, and 300lbs of extra baggage.

What's inside this magical box:

  • javac: The compiler (Go's go build but with more existential dread)
  • java: The JVM launcher (Go's ./binary but needs 500MB RAM to say "hi")
  • jar: Package creator (Like Go binaries but with more zip)
  • 47 other tools you'll never use but must install anyway

Installation Steps (The Ritual): 

# Go: "brew install go"
# Java: 
1. Visit Oracle.com
2. Find download link (pro tip: it's hiding)
3. Accept license agreement (sells soul)
4. Download 200MB installer
5. Run installer (watch progress bar for 5min)
6. Set JAVA_HOME (the variable that haunts dreams)

# Verify installation:
java -version
# Output: java version "21.0.3" 2024-04-16 LTS
# Java(TM) SE Runtime Environment (build 21.0.3+0-LTS)
# Java HotSpot(TM) 64-Bit Server VM (build 21.0.3+0-LTS, mixed mode, sharing)
Enter fullscreen mode Exit fullscreen mode

Why JAVA_HOME exists: Because Java loves making you tell your computer where it lives repeatedly. It's like that friend who can't remember where your house is after 10 visits.

2. IDE Selection: Choosing Your Battle Tank 🎯

Why Java Needs an IDE:

Go: vim main.go → go run → Done ✅

Java: vim HelloWorld.java → 47 compiler errors → Existential crisis → Download IDE 😭

IDE Options Explained:

IntelliJ IDEA (The Fancy Porsche)

  • Purpose: Makes Java feel almost modern
  • Features:
    • Code completion that reads your mind (and sometimes gets it wrong)
    • Refactoring tools that move 100 files at once (pray they're correct)
    • Integrated debugging (because println debugging is beneath Java)
  • Setup:
    1. Download (800MB - "it's fine")
    2. Install (agree to 12 EULAs)
    3. Configure JDK (find that JAVA_HOME you set earlier)
    4. Wait for indexing (go make coffee ☕→ dinner 🍝→ breakfast 🥞)

Eclipse (The Reliable Minivan)

  • Purpose: To remind you that 2003 was a simpler time
  • Features:
    • Free (as in "you'll pay with your sanity")
    • Workspace concept (because one project at a time is for cowards)
    • Plugins that may or may not work today

VS Code (The Scooter)

  • Purpose: For developers who miss Go's simplicity
  • Features:
    • Lightweight (only 500MB with Java extensions!)
    • Requires 17 extensions to make Java work
    • Constantly reminds you it's not a "real" IDE

3. Build Tools: Because go build Was Too Simple 🔨

What are Build Tools?

Imagine if every time you wanted to compile your Go code, you needed to write a 200-line XML file describing your childhood trauma. That's Java build tools.

Maven (The XML Lover):

pom.xml Purpose: To describe your project's entire life story in XML format so Maven can download half the internet to compile one file.

Sample pom.xml structure:

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0.0</version>

    <dependencies>
        <dependency>
            <groupId>org.junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <!-- 47 more dependencies to print "Hello World" -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>
            <!-- 12 more plugins -->
        </plugins>
    </build>
</project>
Enter fullscreen mode Exit fullscreen mode

Gradle (The "Cool" Younger Sibling):

build.gradle Purpose: To do what Maven does but with more complex syntax and the ability to write actual code in your build configuration (because what could go wrong?).

Sample build.gradle:

plugins {
    id 'java'
}

group = 'com.mycompany'
version = '1.0.0'

repositories {
    mavenCentral() // Where all Java packages go to retire
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    // Because you definitely need testing frameworks for Hello World
}

test {
    useJUnitPlatform()
}
Enter fullscreen mode Exit fullscreen mode

4. Project Structure: Folder Inception 📁

Why Java Needs So Many Folders:

Go: main.go → Done

Java: src/main/java/com/company/project/module/package/Class.java → Maybe done

The Official Maven Structure:

my-app/
├── pom.xml                      # 300-line XML confession
├── src/
│   ├── main/                    # "Real" code
│   │   ├── java/                # Java files
│   │   │   └── com/             # Reverse domain (because creativity is punished)
│   │   │       └── mycompany/   # Company name
│   │   │           └── app/     # Project name
│   │   │               └── Main.java # FINALLY THE CODE
│   │   └── resources/           # Config files for your config files
│   │       ├── application.properties
│   │       └── config/
│   │           └── more-config.xml
│   └── test/                    # Code that tests your will to live
│       ├── java/
│       │   └── com/
│       │       └── mycompany/
│       │           └── app/
│       │               └── MainTest.java
│       └── resources/
│           └── test-data.json
└── target/                      # Where compiled dreams go to die
    ├── classes/
    ├── generated-sources/
    ├── maven-status/
    └── my-app-1.0.0.jar
Enter fullscreen mode Exit fullscreen mode

Package Naming Explained:

com.mycompany.app breaks down as:

  • com: Because we're a business, not savages
  • mycompany: Your company name (required to avoid namespace conflicts)
  • app: The actual project name (buried deep where nobody can find it)

Go equivalent: package main 😂

5. Your First Project: The "Hello World" Odyssey 🗺️

Step-by-Step IntelliJ Setup:

  1. Open IntelliJ → Wait 2 minutes for it to load
  2. Create New Project → Java → Maven
  3. GroupId: com.yourcompany (mandatory corporate identity)
  4. ArtifactId: hello-world (the actual project name)
  5. Click Create → Wait 3 minutes for project initialization
  6. Navigate to src/main/java/com/yourcompany/helloworld/App.java
  7. Write code: 
package com.yourcompany.helloworld; // Because package "main" is illegal

public class App { // Class required by law
    public static void main(String[] args) { // Mandatory incantation
        System.out.println("Hello World! I used 50 tools to print this!");
    }
}
Enter fullscreen mode Exit fullscreen mode
  1. Right-click → Run → Wait for Maven to download dependencies
  2. Celebrate when text finally appears! 🎉

What Just Happened:

  1. Maven read your pom.xml
  2. Downloaded 47 dependencies from the internet
  3. Compiled your Java code to bytecode
  4. Started a JVM instance
  5. Loaded your bytecode
  6. Executed the main method
  7. Printed text
  8. Used 500MB RAM to do what Go does with 2MB

Why Java Does This (The Serious Part):

JDK Purpose:

Provides a complete development environment with everything needed to compile, debug, and package Java applications across platforms.

IDE Purpose:

Manages the complexity of large codebases with thousands of classes, provides real-time error checking, and enables refactoring across massive projects.

Build Tools Purpose:

Handle dependency management (critical in Java's massive ecosystem), provide reproducible builds, and standardize project structures across teams.

Package Structure Purpose:

Prevents naming conflicts in enterprise environments where thousands of libraries might be used together.

Final Reality Check 🔍

Go Setup:

# 1. Install Go
# 2. Write main.go
# 3. go run main.go
# Total time: 30 seconds
Enter fullscreen mode Exit fullscreen mode

Java Setup:

# 1. Install JDK (5min)
# 2. Set JAVA_HOME (10min of debugging)
# 3. Install IDE (10min)
# 4. Create project (5min)
# 5. Wait for indexing (15min)
# 6. Write HelloWorld.java (2min)
# 7. Wait for Maven downloads (10min)
# 8. Finally run
# Total time: 57 minutes
# RAM used: 1.2GB
# Sanity lost: Priceless
Enter fullscreen mode Exit fullscreen mode

Moral of the story: Java's complexity comes from solving enterprise-scale problems, but it feels like using a rocket launcher to kill a mosquito when you're just trying to print "Hello World."

Next article: "Dependencies: How Java Downloads Half the Internet to Print Text"

You! Yes, You!

I maintain gofr (a Go framework for happy devs). We need:

  • Bug squashers 🐜
  • Documentation wizards 📜
  • Feature ninjas 🥷
  • Humans who can click "Star" ⭐

No experience? Perfect! Beginners welcome. 👉 GitHub: github.com/gofr-dev/gofr

Help me fix issues so I can instead cry over my Java knowledge. 🙏

Go forth and code! (Or nap. We support both.) 💤💻

Top comments (0)