If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/winterbe/java8-tutorial shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 3y ago

• 11 active contributors
• MIT licensed
• ⚠ Stale — last commit 3y ago
• ⚠ Single-maintainer risk — top contributor 90% of recent commits
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live winterbe/java8-tutorial repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/winterbe/java8-tutorial.

What it runs against: a local clone of winterbe/java8-tutorial — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in winterbe/java8-tutorial | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 1031 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of winterbe/java8-tutorial. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/winterbe/java8-tutorial.git
#   cd java8-tutorial
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of winterbe/java8-tutorial and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "winterbe/java8-tutorial(\\.git)?\\b" \\
  && ok "origin remote is winterbe/java8-tutorial" \\
  || miss "origin remote is not winterbe/java8-tutorial (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f "src/com/winterbe/java8/samples/lambda/Lambda1.java" \\
  && ok "src/com/winterbe/java8/samples/lambda/Lambda1.java" \\
  || miss "missing critical file: src/com/winterbe/java8/samples/lambda/Lambda1.java"
test -f "src/com/winterbe/java8/samples/stream/Streams1.java" \\
  && ok "src/com/winterbe/java8/samples/stream/Streams1.java" \\
  || miss "missing critical file: src/com/winterbe/java8/samples/stream/Streams1.java"
test -f "src/com/winterbe/java8/samples/lambda/Interface1.java" \\
  && ok "src/com/winterbe/java8/samples/lambda/Interface1.java" \\
  || miss "missing critical file: src/com/winterbe/java8/samples/lambda/Interface1.java"
test -f "src/com/winterbe/java8/samples/time/LocalDate1.java" \\
  && ok "src/com/winterbe/java8/samples/time/LocalDate1.java" \\
  || miss "missing critical file: src/com/winterbe/java8/samples/time/LocalDate1.java"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 1031 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1001d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/winterbe/java8-tutorial"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

A comprehensive tutorial and code-sample repository demonstrating Java 8 language features and APIs, with 100+ KB of runnable Java examples covering lambdas, streams, functional interfaces, and the new Date API. It serves as a practical learning resource for understanding how to write modern Java 8+ code with clear, annotated examples rather than lengthy explanations. Simple flat structure: src/com/winterbe/ contains two main branches—java8/samples/ with subdirectories for lambda/, concurrent/, and misc/ example classes, plus java11/ for Java 11+ features. res/ holds Nashorn JavaScript integration examples. Each .java file is a standalone, runnable example class with a main() method and inline comments.

Java developers transitioning from Java 7 or earlier who need concrete, working examples of Java 8 syntax and features like lambda expressions, method references, and the Stream API. Also used by educators teaching modern Java fundamentals through hands-on code samples.

Mature and stable. The repository has 2.4K+ stars on GitHub, was heavily developed around 2014–2015 during Java 8's launch, and includes companion Java 11 tutorial content (src/com/winterbe/java11/). However, the main Java 8 section shows no recent commits, indicating it is feature-complete and maintained as reference material rather than actively developed.

Very low risk for learning purposes. It is a single-author educational repository with no external dependencies (pure Java examples) and no CI/build complexity. The only minor risk is that some examples use the now-deprecated Nashorn JavaScript engine (res/nashorn*.js files), which was removed in Java 15, so those examples will not run on modern JVMs.

No active development. The repository is a static educational resource. Java 11 support was added (java11/ package with HttpClientExamples.java, LocalVariableSyntax.java), but no recent commits are visible. It functions as an archived reference guide rather than a living project.

No build tool config (Maven/Gradle) is present. Clone and compile manually: git clone https://github.com/winterbe/java8-tutorial.git && cd java8-tutorial && javac -d bin src/com/winterbe/java8/samples/**/*.java then run individual example classes with java -cp bin com.winterbe.java8.samples.lambda.Lambda1.

Daily commands: No automated build. Manually compile: javac -d bin src/com/winterbe/java8/samples/lambda/Lambda1.java then java -cp bin com.winterbe.java8.samples.lambda.Lambda1. Each example file has a main() method and runs independently. For Java 11 examples: javac --release 11 -d bin src/com/winterbe/java11/LocalVariableSyntax.java.

• README.md — Entry point documenting Java 8 features; all contributors must understand the tutorial's scope and structure
• src/com/winterbe/java8/samples/lambda/Lambda1.java — Core lambda expression example; foundational to understanding Java 8's primary feature set
• src/com/winterbe/java8/samples/stream/Streams1.java — Introductory streams API sample; demonstrates the most frequently used new collection abstraction
• src/com/winterbe/java8/samples/lambda/Interface1.java — Default methods and functional interface patterns; essential for grasping interface evolution in Java 8
• src/com/winterbe/java8/samples/time/LocalDate1.java — New Date/Time API foundation; replaces legacy Date/Calendar and is critical modern API knowledge
• src/com/winterbe/java8/samples/concurrent/CompletableFuture1.java — Async/concurrent patterns for Java 8; demonstrates the new completable futures model
• src/com/winterbe/java8/samples/nashorn/Nashorn1.java — JavaScript engine integration via Nashorn; unique Java 8 feature for polyglot development

Add a new Lambda/Functional Programming Example

1. Create a new Java file in src/com/winterbe/java8/samples/lambda/ following naming convention Lambda<N>.java (src/com/winterbe/java8/samples/lambda/Lambda5.java)
2. Define a functional interface or use existing ones (@FunctionalInterface annotation) (src/com/winterbe/java8/samples/lambda/Lambda4.java)
3. Provide commented code samples demonstrating the feature with inline output examples (src/com/winterbe/java8/samples/lambda/Lambda1.java)
4. Follow the tutorial style: no verbose explanations, just runnable commented snippets (README.md)

Add a new Stream Processing Example

1. Create a new file in src/com/winterbe/java8/samples/stream/ named Streams<N>.java (src/com/winterbe/java8/samples/stream/Streams13.java)
2. Use Stream API with filter(), map(), reduce(), collect(), or other terminal operations (src/com/winterbe/java8/samples/stream/Streams2.java)
3. Optionally demonstrate parallel streams for performance scenarios (src/com/winterbe/java8/samples/stream/Streams5.java)
4. Include practical examples with built-in collections or custom data structures (src/com/winterbe/java8/samples/stream/Streams1.java)

Add a new Concurrent Programming Example

1. Create a new file in src/com/winterbe/java8/samples/concurrent/ for the concurrency pattern (src/com/winterbe/java8/samples/concurrent/Atomic1.java)
2. Use appropriate utilities: ExecutorService, Lock, Semaphore, AtomicX, or CompletableFuture (src/com/winterbe/java8/samples/concurrent/CompletableFuture1.java)
3. Demonstrate thread-safe patterns and synchronization strategies with code comments (src/com/winterbe/java8/samples/concurrent/Lock1.java)
4. Show practical examples like thread pools, atomic operations, or async composition (src/com/winterbe/java8/samples/concurrent/Executors1.java)

Add a new Nashorn JavaScript Integration Example

1. Create a new Java file in src/com/winterbe/java8/samples/nashorn/ named Nashorn<N>.java (src/com/winterbe/java8/samples/nashorn/Nashorn11.java)
2. Initialize a ScriptEngineManager and get the Nashorn engine for JavaScript execution (src/com/winterbe/java8/samples/nashorn/Nashorn1.java)
3. Optionally add corresponding JavaScript resource file in res/nashorn<N>.js (res/nashorn1.js)
4. Demonstrate Java-JavaScript interop: calling Java from JS or executing JS from Java (src/com/winterbe/java8/samples/nashorn/Nashorn5.java)

• Java 8+ Language Features — Core subject of tutorial; demonstrates lambda expressions, method references, default interface methods, and functional programming paradigm shift in Java
• Stream API — Fundamental new abstraction for functional-style collection processing; replaces imperative iteration loops with declarative pipelines
• java.time Package — Addresses decades-old pain with legacy Date/Calendar classes; provides immutable, thread-safe, ISO-8601 compliant date/time types
• CompletableFuture — undefined

Nashorn JavaScript engine examples (res/nashorn*.js) require Java 8–14 and will fail on Java 15+. Some concurrent examples use raw threads (Threads1.java, Synchronized*.java) which are intentionally simplified for teaching and should not be used in production without proper synchronization patterns. No testing framework is included, so all examples are validation-by-inspection only. Java 11 examples use LocalVariableSyntax (var keyword) which requires javac --release 11 or higher.

• Functional Interface — The @FunctionalInterface contract (single abstract method) is the foundation that allows lambdas to work in Java; understanding this unlocks why lambda syntax compiles and how method references resolve
• Lambda Expression (Closure) — Lambdas capture variables from enclosing scope (closure semantics) and can be assigned to functional interface types; this repo shows practical closure patterns in concurrent examples like Executors1.java
• Stream API (Lazy Evaluation) — Streams are lazy (operations defer until terminal operation) and enable functional composition; critical for writing clean, declarative data transformations shown in the Filter/Map/Reduce sections of README
• Method Reference — Method references (e.g., String::valueOf, System.out::println) are syntactic sugar for lambdas pointing to existing methods; this repo demonstrates all four kinds (static, bound, unbound, constructor) in samples/lambda/
• Default Methods (Virtual Extension Methods) — Interfaces can now have concrete implementations; this resolved the evolution problem (how to add methods to interfaces without breaking implementations) and enabled the Stream API design
• CompletableFuture (Composable Async) — CompletableFuture allows chaining asynchronous operations (thenApply, thenCompose) without nested callbacks; src/com/winterbe/java8/samples/concurrent/CompletableFuture1.java shows the pattern essential for async Java
• Type Inference (Local Variable Type) — Java 8 improved type inference for generics and lambdas (e.g., (x, y) -> x + y infers parameter types); Java 11 extends this with var keyword shown in java11/LocalVariableSyntax.java for cleaner code

• oracle/openjdk — Official Java Development Kit source; provides the JDK 8 runtime and library implementations referenced in all examples
• winterbe/java11-tutorial — Direct successor repository by the same author; covers Java 9, 10, 11 features (HttpClient, var keyword, modules) building on Java 8 fundamentals
• donnemartin/system-design-primer — Contains Java concurrency and design pattern references; complementary for understanding when to apply CompletableFuture and concurrent utilities from this repo in large systems
• vavr-io/vavr — Functional programming library for Java that extends the functional patterns (immutability, monads, pattern matching) introduced in Java 8 streams and lambdas
• reactivex/rxjava — Reactive streams library built on top of Java 8 lambdas and functional interfaces; natural evolution for those mastering CompletableFuture and Stream patterns in this tutorial

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive unit tests for Stream API examples

The repo contains 10+ Stream examples (Streams1.java through Streams10.java) but lacks corresponding unit tests. This would help verify that all stream operations work correctly across different Java versions and provide a testing template for learners. Tests should cover intermediate and terminal operations, collectors, and edge cases.

• [ ] Create src/test/java/com/winterbe/java8/samples/stream/ directory structure
• [ ] Write unit tests for each Streams*.java file (e.g., Streams1Test.java, Streams2Test.java, etc.)
• [ ] Add tests for Optional1.java and Optional2.java with null-handling edge cases
• [ ] Create a test runner or Maven/Gradle configuration to execute all tests
• [ ] Document how to run tests in README.md

Add unit tests for concurrent utilities and thread safety examples

The src/com/winterbe/java8/samples/concurrent/ directory contains 18+ files covering complex topics like locks, atomics, and executors, but has no tests to verify thread-safety behavior. Adding tests would validate that concurrent patterns work correctly and serve as executable documentation for concurrency best practices.

• [ ] Create src/test/java/com/winterbe/java8/samples/concurrent/ directory
• [ ] Write tests for Atomic1.java (AtomicInteger/AtomicReference behavior)
• [ ] Write tests for CompletableFuture1.java (async composition, exception handling)
• [ ] Write tests for Lock1-Lock6.java (mutual exclusion, fairness, conditions)
• [ ] Write tests for Synchronized1.java and Synchronized2.java (monitor behavior)
• [ ] Add integration tests for ConcurrentHashMap1.java and ConcurrentUtils.java

Create a Maven/Gradle build configuration with Java version matrix testing

The repo targets Java 8 and Java 11 (based on directory structure) but lacks build automation. Adding Maven or Gradle with compiler configurations and a GitHub Actions workflow to test against multiple Java versions (8, 11, 17+) would ensure backward/forward compatibility and catch version-specific issues early.

• [ ] Create pom.xml with maven-compiler-plugin configured for Java 8+ source/target compatibility
• [ ] Configure separate profiles for java8, java11, and java17 compilation targets
• [ ] Add maven-surefire-plugin for running any existing/new tests
• [ ] Create .github/workflows/build.yml to test against JDK 8, 11, 17 on push/PR
• [ ] Update README.md with build and test instructions

• Add a streams examples file (e.g., src/com/winterbe/java8/samples/streams/Streams1.java, Streams2.java) with concrete examples of map(), filter(), reduce(), and collect() operations—the README mentions Streams in the table of contents but no dedicated .java file exists
• Document the Nashorn examples or mark them as deprecated: either add a comment in res/ explaining they require Java 8–14, or create a src/com/winterbe/java8/samples/nashorn/NashornExamples.java with wrapper code and a note in README.md that this feature was removed
• Add missing functional interface examples: create src/com/winterbe/java8/samples/funcinterfaces/CustomFunctionalInterface.java demonstrating how to write @FunctionalInterface interfaces and composition (similar to what's documented in the README but missing executable code)

This is an educational Java 8/11 tutorial repository with moderate security concerns. Primary issues include: (1) reliance on the deprecated/removed Nashorn JavaScript engine which will not receive security updates, (2) absence of explicit dependency management configuration making vulnerability tracking impossible, and (3) typical tutorial content risks where simplified examples lack security best practices. The repository itself contains no credentials, SQL injection risks, or infrastructure misconfigurations detected. Recommendations focus on modernizing the Nashorn examples, establishing dependency management, and enhancing security documentation in code samples.

• High · Use of Nashorn JavaScript Engine (Deprecated and Removed) — src/com/winterbe/java8/samples/nashorn/ (all Nashorn*.java files) and res/nashorn*.js files. The codebase contains extensive use of the Nashorn JavaScript engine (11 Nashorn example files and corresponding JS resources). Nashorn was deprecated in Java 10 and removed in Java 15. Using deprecated/removed features poses security risks as they no longer receive security updates and patches. Fix: Replace Nashorn with GraalVM JavaScript or another actively maintained JavaScript engine. Update code samples to use modern alternatives.
• Medium · No Dependency Management Configuration — Root directory - missing build configuration files. The provided context shows no pom.xml, build.gradle, or other dependency management file. This makes it impossible to track, audit, or update dependencies for known vulnerabilities. Tutorial code may have outdated library versions with unpatched security issues. Fix: Add Maven (pom.xml) or Gradle (build.gradle) configuration to manage dependencies explicitly. Use dependency checking tools like OWASP Dependency-Check or Maven security plugin.
• Low · Potential Unsafe Reflection Usage in Examples — src/com/winterbe/java8/samples/nashorn/ and general sample code. As an educational repository, code samples may demonstrate reflection, scripting engines, or dynamic class loading without security considerations. While appropriate for tutorials, these examples could be misused if copy-pasted into production code without proper input validation. Fix: Add security warnings and best practices documentation in code comments. Include validation examples for any dynamic code execution or reflection usage.
• Low · No Input Validation Examples in HTTP Client Code — src/com/winterbe/java11/HttpClientExamples.java. HttpClientExamples.java in Java 11 section may contain HTTP operations without demonstrated input validation or sanitization patterns, though actual content cannot be verified from file structure alone. Fix: Ensure all HTTP client examples include proper input validation, SSL/TLS certificate validation, and secure header examples.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.