Course audit report

Object Oriented Programming 1

Done Role: Backend Engineer 10 Findings Object-Oriented Programming With Java — Fundamentals
Auditor Done Market Fit Done Topics Done
Run another role
10 findings · 6 high 3 medium 1 low
No longer works 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.
Why this is flagged

The slide presents Java applets as a current capability of Java SE. Applet support has been deprecated for removal across multiple JDK versions (browsers stopped supporting the plug-in years ago) and the Applet API is being eliminated from the platform — students should not be told this is a real deployment target.

Adjudicator's note: The slide unambiguously presents applets as a current Java SE feature, with no nearby contrast slide marking it as obsolete. Oracle's own migration documentation confirms the Applet API is gone.

Primary source ✓ Source checked

docs.oracle.com ↗

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.

Misleading idea 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.
Why this is flagged

The slide conflates Java's 16-bit `char` with Unicode itself. Unicode is not a 16-bit encoding scheme and is not capped at 65,536 characters; it defines code points up to U+10FFFF. Java's `char` is one UTF-16 code unit, and characters outside the Basic Multilingual Plane require surrogate pairs.

Adjudicator's note: Slide presents the 16-bit/65,536 claim as fact, with no follow-up on supplementary characters or surrogate pairs anywhere in the lecture. Oracle's own Character class documentation explicitly contrasts the original 16-bit assumption with the current U+0000–U+10FFFF range.

Primary source ✓ Source checked

docs.oracle.com ↗

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.

Will not run as shown Lecture 05 - Thinking in Objects.pdf page 18, Lecture 08 - Abstract Classes and Interfaces.pdf page 9

What the slide says

+longVlaue(): long
Why this is flagged

The UML method label is misspelled `longVlaue` instead of `longValue`. The standard `Number` superclass declares `longValue()`; `longVlaue()` is not a method on Integer, Double, or Number. A student translating the diagram literally will get 'cannot find symbol method longVlaue'.

Adjudicator's note: The misspelling appears as plain (non-OCR) UML text on Lecture 05 page 18 and is corroborated by the OCR'd Number-class diagram on Lecture 08 page 9, so it is genuinely on the slide and not an OCR artifact. The Number javadoc lists the correct spelling `longValue()`.

Primary source ✓ Source checked

docs.oracle.com ↗

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.

Will not run as shown Lecture 05 - Thinking in Objects.pdf page 23

What the slide says

Double.parseDouble(number, 23); // with default Base 23
Why this is flagged

`java.lang.Double` does not have a 2-argument `parseDouble(String, int)` overload, nor a 2-argument `valueOf(String, int)`. Floating-point parsing in the JDK is base-10 only — radix arguments only exist on integer wrapper classes (`Integer`, `Long`, `Short`, `Byte`). The slide explicitly tells students they can parse base-23 floating point numbers, which is wrong and will not compile.

Adjudicator's note: The phantom signature appears both in the page 18 UML and as concrete code on page 23 with no contrast slide. The Double javadoc lists only the single-argument `parseDouble(String)` and the single-argument `valueOf(String)`.

Primary source ✓ Source checked

docs.oracle.com ↗

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.

Gives wrong result Lecture 05 - Thinking in Objects.pdf page 19

What the slide says

Integer Val3 = Integer.valueOf("10.3");
Why this is flagged

`Integer.valueOf(String)` is for integer literals only; `"10.3"` is not a parsable integer, so this line throws `NumberFormatException` at runtime. The slide presents it as a working autoboxing example with no error annotation.

Adjudicator's note: Slide groups this with two valid `Integer.valueOf` calls and labels the whole block 'autoboxing' — it is presented as a runnable demonstration with no warning. The Integer.valueOf(String) javadoc explicitly throws NumberFormatException for non-integer input.

Primary source ✓ Source checked

docs.oracle.com ↗

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.

Will not run as shown Lecture 05 - Thinking in Objects.pdf page 22

What the slide says

Double DVal1 = Double.ValueOf(34.5); Double DVal2 = Double.ValueOf(“10.3”);
Why this is flagged

The static factory method on `Double` is `valueOf` (lowercase v), not `ValueOf`. Java is case-sensitive, so `Double.ValueOf(...)` resolves to nothing and produces a compile error 'cannot find symbol method ValueOf'.

Adjudicator's note: Same slide shows `Integer.valueOf` with the correct lowercase name two lines earlier, then uses `Double.ValueOf` capitalized — this is a typo, not a stylistic alternative, and Java's case sensitivity makes it a hard compile error. Double javadoc confirms the correct name is `valueOf`.

Primary source ✓ Source checked

docs.oracle.com ↗

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.)

Deprecated Lecture 04 - OOP Basics.pdf page 26

What the slide says

java.util.Date date = new java.util.Date();
Why this is flagged

The course teaches `java.util.Date`, `java.util.Calendar`, and `java.util.GregorianCalendar` as the standard date/time abstractions. This API has been formally superseded since Java 8 by `java.time` (`LocalDate`, `LocalDateTime`, `Instant`, `ZonedDateTime`). The legacy classes also expose deprecated members (e.g. most date-component getters/setters and several `Date` constructors are `@Deprecated` since JDK 1.1) — students learning these as the canonical API leave with an outdated mental model.

Adjudicator's note: Multiple slides introduce these classes as the prescribed API for working with dates and times, with no slide pointing students at `java.time`. Oracle's own Date javadoc has long deprecated most of the API; the modern replacement is the `java.time` package.

Primary source ✓ Source checked

docs.oracle.com ↗

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.

Deprecated Lecture 05 - Thinking in Objects.pdf page 19

What the slide says

Integer Val1 = new Integer(1);
Why this is flagged

The `Integer(int)` and `Integer(String)` constructors have been formally `@Deprecated` since JDK 9 in favor of `Integer.valueOf(int)` (which caches small values). The slide shows `new Integer(1)` as a recommended construction style alongside `Integer.valueOf(1)`.

Adjudicator's note: Both slides use `new Integer(...)` as live example code with no note that the constructor is deprecated. Oracle's Integer javadoc has carried the `@Deprecated` annotation since Java 9.

Primary source ✓ Source checked

docs.oracle.com ↗

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)`.

Deprecated Lecture 05 - Thinking in Objects.pdf page 26

What the slide says

BigDecimal c = a.divide(b, 20, BigDecimal.ROUND_UP);
Why this is flagged

The integer rounding-mode constants on `BigDecimal` (`ROUND_UP`, `ROUND_HALF_EVEN`, etc.) are formally deprecated since JDK 9; the corresponding `divide(BigDecimal, int, int)` overload is also deprecated. New code should use the `java.math.RoundingMode` enum. The example will compile but emits deprecation warnings.

Adjudicator's note: Slide uses `BigDecimal.ROUND_UP` as the recommended rounding mode in a worked example. The BigDecimal javadoc explicitly says the integer rounding-mode fields are deprecated and `RoundingMode` should be used instead.

Primary source ✓ Source checked

docs.oracle.com ↗

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.

Misleading idea Lecture 05 - Thinking in Objects.pdf page 28

What the slide says

String s = new String();
Why this is flagged

The slide teaches `new String()` and `new String("...")` as standard String construction styles. Both constructors are documented in the JDK as unnecessary because Strings are immutable; `new String(literal)` in particular bypasses string interning and creates a redundant object. Modern Java style guides and IDE inspections flag both as code smells.

Adjudicator's note: Page 28 introduces all three forms under the heading 'Creating a String' with no caveat. The Java SE 21 String javadoc explicitly states 'use of this constructor is unnecessary since Strings are immutable' for both `String()` and `String(String original)`.

Primary source ✓ Source checked

docs.oracle.com ↗

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[]).

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.

No extendable gaps for this role

Stale only flags gaps that the course already partially covers. It won't push you toward Kubernetes when you're sitting in a Unicode course. For backend, every high-frequency market demand is in a different area from what this course actually teaches.

Try a different target role on the run page, or run Stale on a course whose subject area overlaps the role you're aiming for.

What the curriculum actually teaches (27 skills)
  • Java syntax fundamentals (variables, primitive types, operators, casting) · Lecture 02 - Java Basics - Part I
    Slide 21 'Variable Declaration': 'int x; double radius; char a;'; Slide 31 'Type Casting': 'int i = (int)3.0; (type narrowing)'
  • Java control flow (if/else, switch, ternary) · Lecture 02 - Java Basics - Part I
    Slide 35 'One-way IF Statements'; Slide 45 'switch Statements'; Slide 50 '? : Conditional Operator': 'y = (x > 0) ? 1 : -1;'
  • Java loops (while, do-while, for, for-each, break/continue) · Lecture 03 - Java Basics - Part 2
    Page 8 'while Loop'; Page 17 'Do – While Loop'; Page 20 'for Loops'; Page 73 'Enhanced FOR Loop (for-each loop)': 'for (type var : array) { statements using var; }'
  • Methods, parameters, overloading, scope · Lecture 03 - Java Basics - Part 2
    Page 41 'Defining Methods (Example)': 'public static int max(int num1, int num2)'; Page 53 'Overloading Methods'; Page 55 'Scope and Lifetime of Variables'
  • 1D and 2D arrays, anonymous arrays, java.util.Arrays.sort · Lecture 03 - Java Basics - Part 2
    Page 65 'How to Create Array using Java?': 'int[] intArray = new int[100];'; Page 82 'Operation on Array: Sorting': 'java.util.Arrays.sort(numbers);'
  • Enumerated types (enum) · Lecture 03 - Java Basics - Part 2
    Page 97 'Introduction': 'static enum Day {SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY};'
  • Console I/O via java.util.Scanner and System.out.print/println/printf · Lecture 02 - Java Basics - Part I
    Slide 25 'Reading Input from the Console (Keyboard)': 'Scanner input = new Scanner(System.in); double d = input.nextDouble();'; Slide 75 'Formatting Output': 'System.out.printf(format, items);'
  • java.lang.Math class (trig, exp, rounding, abs/min/max/random) · Lecture 02 - Java Basics - Part I
    Slide 57 'Mathematical Functions': 'mathematical functions are implemented as methods on the Math-Class'; 'Math.pow(2, 3) returns 8.0; Math.sqrt(4) returns 2.0'
  • java.lang.String API (length, charAt, substring, indexOf, concat, equals, compareTo) · Lecture 02 - Java Basics - Part I, Lecture 05 - Thinking in Objects
    L02 Slide 67 'Simple Methods for String Objects': 'message.length()'; L02 Slide 70 'String Concatenation': 'String s3 = s1.concat(s2);'; L05 Page 28 'The String Class' lists length/concat/substring/equals/compareTo
  • Defining classes, fields, constructors, accessor/mutator (getters/setters) · Lecture 04 - OOP Basics
    Page 9 'Class Example': 'class Circle { double radius = 1.0; Circle() {} Circle(double newRadius) {radius = newRadius;} double getArea() {...} }'; Page 35 'Accessor / Mutator Methods': 'public int getNumber() { return number; } public void setNumber(int newNumber) { number = newNumber; }'
  • Encapsulation and access/visibility modifiers (public, private, protected, default) · Lecture 04 - OOP Basics, Lecture 06 - Inheritance
    L04 Page 30 'Access / Visibility Modifiers': 'There are four types of access/visibility modifiers available in java: Default, Public, Private, Protected'; L05 Page 6 'Class Abstraction and Encapsulation': 'We can create a fully encapsulated class in java by making all the data members of the class private.'
  • Static vs instance members, the 'this' keyword · Lecture 04 - OOP Basics
    Page 28 'Instance Variables, and Methods': 'Static variables are shared by all the instances of the class.'; Page 46 'The this Keyword': 'this.i = i;'
  • Garbage collection / JVM memory management (introductory awareness) · Lecture 04 - OOP Basics
    Page 25 'Garbage Collection': 'Garbage collection (GC) is a form of automatic memory management in Java. Garbage is automatically collected by JVM.'
  • Class relationships: association, aggregation, composition (UML) · Lecture 05 - Thinking in Objects
    Page 9 'Object Association'; Page 11 'Aggregation and Composition': 'It represents Has-A relationship.'; Page 13 'Composition is a restricted form of Aggregation'
  • Wrapper classes (Integer, Double, etc.), autoboxing/unboxing · Lecture 05 - Thinking in Objects
    Page 17 'Wrapper Classes': 'Converting primitive data types into object is called boxing (done by compiler), while Wrapper object converted back to a primitive data type is called unboxing.'
  • java.math.BigInteger and BigDecimal for arbitrary-precision arithmetic · Lecture 05 - Thinking in Objects
    Page 25 'BigInteger and BigDecimal': 'The BigInteger and BigDecimal classes are defined in the java.math package.'
  • StringBuilder / StringBuffer (mutable strings) · Lecture 05 - Thinking in Objects
    Page 36 'StringBuilder and StringBuffer': 'StringBuilder/StringBuffer is more flexible than String. You can add, insert, or append new contents...'
  • Regular expressions in Java (String.matches, replaceAll, split) · Lecture 05 - Thinking in Objects
    Page 33 'Matching, Replacing and Splitting by Patterns': '"Java is fun".matches("Java.*");'; Page 39 'Regular Expressions': 'A regular expression (regex) defines a search pattern for strings.'
  • Inheritance via extends, super keyword, constructor chaining · Lecture 06 - Inheritance
    Page 8 'Inheritance': 'class derived-class extends base-class'; Page 14 'Using the Keyword super'; Page 18 'Constructor Chaining': 'the subclass constructor first invokes its superclass constructor before performing its own tasks.'
  • Method overriding (@Override) and overloading; rules and contrasts · Lecture 06 - Inheritance, Lecture 07 - Polymorphism
    L06 Page 32 'Rules for Overriding Methods': 'place @Override before the method in the subclass'; L06 Page 34 'Overriding vs. Overloading'; L07 Page 6 'Compile-Time Polymorphism' (overloading) and Page 7 'Runtime Polymorphism' (overriding)
  • java.lang.Object root class, toString(), equals(), hashCode() · Lecture 06 - Inheritance, Lecture 07 - Polymorphism
    L06 Page 36 'The Object Class and Its Methods': 'Every class in Java is derived from the java.lang.Object class'; L07 Page 21 'The equals Method': 'In java equals() method is used to compare equality of two Objects.'
  • Polymorphism, dynamic binding, upcasting, instanceof, explicit casting · Lecture 07 - Polymorphism
    Page 8 'Runtime Polymorphism Upcasting': 'A a=new B();//upcasting'; Page 13 'Dynamic Binding'; Page 19 'The instanceof Operator': 'if (myObject instanceof Circle) {...}'
  • java.util.ArrayList<E> (introductory generics use) · Lecture 07 - Polymorphism
    Page 23 'The ArrayList Class': 'ArrayList<E> ... <E> is a generic Datatype, used to store anytype of data in ArrayList.'; Page 26 'ArrayList<String> alist=new ArrayList<String>();'
  • Abstract classes and abstract methods · Lecture 08 - Abstract Classes and Interfaces
    Page 6 'Abstract Class Declaration': 'abstract class A{ abstract void myMethod(); ... }'; Page 7 'An abstract method cannot be contained in a non-abstract class'
  • Interfaces, multiple-interface implementation, Comparable, Cloneable · Lecture 08 - Abstract Classes and Interfaces
    Page 15 'Interface': 'public interface NameOfInterface { ... }'; Page 19 'The Comparable Interface': 'public interface Comparable<E> { public int compareTo(E o); }'; Page 23 'The Cloneable Interfaces'
  • java.util.Date / java.util.Calendar / GregorianCalendar · Lecture 04 - OOP Basics, Lecture 08 - Abstract Classes and Interfaces
    L04 Page 26 'The Date Class': 'java.util.Date date = new java.util.Date();'; L08 Page 10 'Abstract Calendar Class and Its GregorianCalendar subclass'
  • java.util.Random class · Lecture 04 - OOP Basics
    Page 27 'The Random Class': 'a more useful random number generator is provided in the java.util.Random class. Random random1 = new Random(3);'

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.

These prescriptions close 0% of the surfaced market gap — because there is no in-scope gap to close. The course is internally coherent: it teaches Java OOP fundamentals (syntax, classes, inheritance, polymorphism, abstract classes, interfaces) and the backend market gaps (SQL, Postgres, REST, Docker, AWS, K8s, Kafka, OAuth/JWT, microservices, CI/CD, Prometheus) are downstream courses, not extensions of these lectures. The right place to address them is a follow-on databases course, a web/REST course, and a DevOps/cloud course — not by bolting Spring Boot or JDBC onto Lecture 08. Per Rule 3, padding this list with pseudo-prescriptions like 'add a JDBC intro to Lecture 05' or 'demo Docker in Lecture 04' would violate the depth bound and is therefore omitted. Note also that the Auditor flagged 21 patterns in this course (deprecated `java.util.Date`, broken `new Integer(1)`, `BigDecimal.ROUND_UP`, applet references, identifier-casing errors, missing `String[] args`, `pritnln`, `longVlaue`, etc.) — fixing those is a correctness/hygiene job for the course owner, not a market-driven topic prescription, so they are out of scope for this agent.