# Object Oriented Programming 1 — Stale course audit

- URL: https://getstale.tech/run/refactor_oop1_20260505T215900Z
- Target role: Backend Engineer
- Course focus: Object-Oriented Programming With Java — Fundamentals
- Audit date: 2026-05-05T21:59:00Z
- Verified findings: 10
- Structured data: https://getstale.tech/run/refactor_oop1_20260505T215900Z.json

## Findings

### 1. No longer works (high severity)

**Location:** Lecture 02 - Java Basics - Part I.pptx slide 10

**What the slide says:**

> Java Standard Edition (Java SE) to develop client-side applications. The applications can run standalone or as applets running from a Web browser.

**Primary source:** https://docs.oracle.com/en/java/javase/25/migrate/removed-tools-and-components.html (verified)

> The Applet API has been deprecated for removal as all web-browser vendors have either removed support for Java browser plug-ins or announced plans to do so.

**What to learn instead:** Drop the applet line entirely. Java SE today targets desktop apps via JavaFX/Swing or command-line/server processes; there is no supported way to run applets in a modern browser. Alternatives are JNLP-less Java Web Start replacements, JPackage-built native installers, or just running Java as a standalone process.

### 2. Misleading idea (high severity)

**Location:** Lecture 02 - Java Basics - Part I.pptx slide 63

**What the slide says:**

> Java characters use Unicode, a 16-bit encoding scheme established by the Unicode Consortium to support the interchange, processing, and display of written texts in the world's diverse languages. Unicode takes two bytes, preceded by \u, expressed in four hexadecimal numbers that run from '\u0000' to '\uFFFF'. So, Unicode can represent 65535 + 1 characters.

**Primary source:** https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Character.html (verified)

> The char data type (and therefore the value that a Character object encapsulates) are based on the original Unicode specification, which defined characters as fixed-width 16-bit entities. The Unicode Standard has since been changed to allow for characters whose representation requires more than 16 bits. The range of legal code points is now U+0000 to U+10FFFF, known as Unicode scalar value.

**What to learn instead:** Teach: Unicode defines code points from U+0000 to U+10FFFF. Java's `char` is a 16-bit UTF-16 code unit and only represents BMP code points directly; supplementary characters (U+10000–U+10FFFF) are represented as a surrogate pair of two `char` values. Use `String.codePointAt`, `Character.codePointCount`, or `String.codePoints()` when iterating real characters.

### 3. Will not run as shown (high severity)

**Location:** Lecture 05 - Thinking in Objects.pdf page 18, Lecture 08 - Abstract Classes and Interfaces.pdf page 9

**What the slide says:**

> +longVlaue(): long

**Primary source:** https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Number.html (verified)

> abstract long longValue() Returns the value of the specified number as a long.

**What to learn instead:** Correct the diagram label to `+longValue(): long`. Same for any other UML diagrams in the deck that copy this typo.

### 4. Will not run as shown (high severity)

**Location:** Lecture 05 - Thinking in Objects.pdf page 23

**What the slide says:**

> Double.parseDouble(number, 23); // with default Base 23

**Primary source:** https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Double.html (verified)

> public static double parseDouble(String s) throws NumberFormatException

**What to learn instead:** Drop the radix line for `Double`. If the goal is parsing a decimal: `Double.parseDouble("10.3")`. If the goal is integer parsing in another base, use `Integer.parseInt(s, radix)` or `Long.parseLong(s, radix)` and accept that it returns an integral type.

### 5. Gives wrong result (high severity)

**Location:** Lecture 05 - Thinking in Objects.pdf page 19

**What the slide says:**

> Integer Val3 = Integer.valueOf("10.3");

**Primary source:** https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Integer.html (verified)

> Throws: NumberFormatException - if the string cannot be parsed as an integer.

**What to learn instead:** If the input is `"10.3"`, parse with `Double.valueOf("10.3")` or `Double.parseDouble("10.3")`. If the intent is to truncate to an int, do `(int) Double.parseDouble("10.3")`. `Integer.valueOf(String)` only accepts characters that form a valid signed integer in base 10.

### 6. Will not run as shown (high severity)

**Location:** Lecture 05 - Thinking in Objects.pdf page 22

**What the slide says:**

> Double DVal1 = Double.ValueOf(34.5); Double DVal2 = Double.ValueOf(“10.3”);

**Primary source:** https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Double.html (verified)

> public static Double valueOf(String s) throws NumberFormatException

**What to learn instead:** Use lowercase `valueOf`: `Double dVal1 = Double.valueOf(34.5); Double dVal2 = Double.valueOf("10.3");`. (Also rename the variables to camelCase to match Java convention.)

### 7. Deprecated (medium severity)

**Location:** Lecture 04 - OOP Basics.pdf page 26

**What the slide says:**

> java.util.Date date = new java.util.Date();

**Primary source:** https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Date.html (verified)

> As of JDK 1.1, the Calendar class should be used to convert between dates and time fields and the DateFormat class should be used to format and parse date strings. The corresponding methods in Date are deprecated.

**What to learn instead:** Teach `java.time` (introduced in Java 8): `LocalDate.now()`, `LocalDateTime.now()`, `Instant.now()`, `ZonedDateTime.of(...)`. Use `DateTimeFormatter` for formatting and parsing. `java.util.Date`/`Calendar`/`GregorianCalendar` are kept only for legacy-API interop.

### 8. Deprecated (medium severity)

**Location:** Lecture 05 - Thinking in Objects.pdf page 19

**What the slide says:**

> Integer Val1 = new Integer(1);

**Primary source:** https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html (verified)

> Deprecated. It is rarely appropriate to use this constructor. The static factory valueOf(int) is generally a better choice, as it is likely to yield significantly better space and time performance.

**What to learn instead:** Replace with `Integer.valueOf(1)` or just rely on autoboxing: `Integer val1 = 1;`. Same idea for `new Integer(3).compareTo(new Integer(5))` on Lecture 08 page 20 — write `Integer.valueOf(3).compareTo(5)` or `Integer.compare(3, 5)`.

### 9. Deprecated (medium severity)

**Location:** Lecture 05 - Thinking in Objects.pdf page 26

**What the slide says:**

> BigDecimal c = a.divide(b, 20, BigDecimal.ROUND_UP);

**Primary source:** https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html (verified)

> Using the integer fields in this class (such as ROUND_HALF_UP) to represent rounding mode is deprecated; the enumeration values of the RoundingMode enum, (such as RoundingMode.HALF_UP) should be used instead.

**What to learn instead:** Replace with the enum form: `BigDecimal c = a.divide(b, 20, RoundingMode.UP);` (and `import java.math.RoundingMode;`). Also prefer `BigDecimal.valueOf(1.0)` or `new BigDecimal("1.0")` over the `double`-taking `BigDecimal(double)` constructor for non-trivial values.

### 10. Misleading idea (low severity)

**Location:** Lecture 05 - Thinking in Objects.pdf page 28

**What the slide says:**

> String s = new String();

**Primary source:** https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/String.html (verified)

> Initializes a newly created String object so that it represents an empty character sequence. Note that use of this constructor is unnecessary since Strings are immutable.

**What to learn instead:** Use string literals: `String message = "Welcome to Java";` for the empty case `String s = "";`. Reserve `new String(...)` constructors for the few cases where you really need a fresh object (e.g. defeating string interning intentionally, or copying a substring's underlying char[]).

## Market fit

An introductory Java OOP course taught faithfully to its own scope: every market skill demanded by ≥30% of backend postings (SQL, REST APIs, Postgres, Docker, AWS, Linux, Git, CI/CD, microservices, Kubernetes, Kafka, OAuth/JWT, Redis, Prometheus, etc.) sits in databases, web protocols, infrastructure, or DevOps domains entirely outside this course's depth bound, and no slide partially covers them — so under the 'extend partial coverage only' rule there are no actionable in-scope gaps to surface.

## Recommended topics

No prescriptions issued. Market-fit returned gap_count = 0: every backend skill demanded by ≥30% of the 12 analyzed postings (SQL @ 100%, REST API @ 92%, Postgres @ 92%, Docker @ 92%, unit testing @ 83%, AWS @ 83%, Linux @ 75%, Git @ 75%, CI/CD @ 67%, microservices @ 67%, Python/OAuth/Redis/Kubernetes @ 58%, Kafka/GraphQL/JWT @ 50%, etc.) lives in databases, web/HTTP, cloud infra, or DevOps domains that no slide in this introductory Java OOP course even partially covers. Under Rule 1 (extend partial coverage only) and Rule 2 (respect the depth bound of an undergraduate Java syntax + OOP fundamentals course), none of these can be honestly hosted in any of Lectures 02–08 without inventing a gap or pushing the course beyond its stated scope.

---
Produced by Stale (https://getstale.tech). Request a course audit: https://getstale.tech/request-audit