The Problem with Teaching Java

 

For many years, Java was often taught by focusing on the tools rather than on the underlying concepts.

A student might learn:

  • Applets
  • Swing
  • JSP
  • Servlets
  • JDBC

In my particular case, my first experience with Java was through an applet. The focus was on demonstrating that Java could run inside a graphical application or a web browser, but not necessarily on understanding broader concepts such as object-oriented design, separation of responsibilities, or application architecture.

Because an applet alone does not explain:

Class
  |
Object
  |
Responsibility
  |
Collaboration Between Objects
  |
Complete System

A student could understand how to create an Applet and override a method such as paint(), but that did not necessarily prepare them to design an enterprise application.

At that stage, I still did not fully understand concepts such as:

  • Object-Oriented Programming.
  • Class responsibilities.
  • Separation of layers.
  • Client-server architecture.
  • Data persistence.
  • Application design.

For example, a web application could begin with a structure like this:

JSP
 |
 ├── HTML
 ├── Java
 ├── SQL
 └── Business Logic

This approach allowed developers to build functional applications, but as the system grew, maintenance and organization became increasingly difficult.

The next step was understanding a more structured architecture:

View
 |
 ▼
Controller
 |
 ▼
Service
 |
 ▼
Repository
 |
 ▼
Database

At that point, object-oriented programming started to make much more sense because classes were no longer just containers for code—they represented well-defined responsibilities within the system.

Too Many Tools, Too Early

Another problem was that frameworks were often introduced before students understood the fundamentals.

A student could learn something like:

@GetMapping("/products")

without necessarily understanding that, behind the scenes, there is an HTTP request flow that was historically implemented using Servlets.

Understanding the following first:

HTTP Request
      |
      ▼
Servlet
      |
      ▼
Java Code
      |
      ▼
HTTP Response

makes it much easier to understand which problems modern frameworks are actually solving.

The Importance of Layers

A real application is much more than a user interface. It consists of different responsibilities:

User
  |
View
  |
Controller
  |
Service
  |
Data
  |
Database

Once these layers are understood, technologies such as Spring Boot, Jakarta EE, and other frameworks stop being black boxes and become tools that automate solutions developers already understand.

Conclusion

Java is not difficult simply because of its syntax.

In many cases, the real challenge comes from learning programming concepts and software architecture at the same time as learning the language itself.

A progressive learning path could be structured as follows:

  1. Object-Oriented Programming.
  2. Object Modeling.
  3. Separation of Responsibilities.
  4. Data Persistence.
  5. Web Applications.
  6. Frameworks.

First understand the building blocks.

Then use tools that automate those building blocks.

Comments

Post a Comment

Popular posts from this blog

Building a Simple Web Form with Jetty and Servlets

In this article, we will learn how to create a small web application using Java, Jetty, Thymeleaf, and Servlets. We will not use frameworks like Spring Boot because our goal is to understand how a web application works. Before beginning, we need the following requirements: Understanding how a web application works Fundamentals of programming Java 11 or higher Knowledge of how Maven works An IDE of your choice In my case, I will use NetBeans. In NetBeans, I will create a Maven Project → Java Application. We need to edit the pom.xml file because it contains the following dependencies: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">     <modelVersion>4.0.0</modelVersion>     <groupId>com.egga</groupId>     ...
Read more

Creating a MySQL Connection Class in Java

Creating a MySQL Connection Class in Java June 19, 2026 When I started learning Java, one of the first tasks was connecting to a MySQL database. To achieve this, it is common practice to create a class responsible for centralizing the connection configuration and providing Connection objects to the rest of the application. Basic Example package com.egga.appvet.includes; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Connection; public class ConexionBD { private static final String URL = "jdbc:mysql://localhost:3306/AppVet"; private static final String USER = "tuusuario"; private static final String PASS = "tupassword@"; public static Connection getConnection() throws SQLException { return DriverManager.getConnection(URL, USER, PASS); } } In this example, three constants are defined: URL : the MySQL database address. U...
Read more

Replacing Tomcat: Configure Jetty with Spring Boot

 I this article we will learn how to configure Jetty with SpringBoot. I will not use Spring Initializr. Jetty is fast and lightweight, making it ideal for high-performance applications. Being modular, it allows enabling only the necessary components, optimizing resource usage. Jetty efficiently handles high traffic volumes, enabling applications to scale seamlessly. Add Dependencies to pom.xml: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.egga</groupId> <artifactId>examplejetty</artifactId> <version>0.1</version> <packaging>jar</packaging> <properties> <project.build.sourceEncoding>UTF-8</project.build.s...
Read more