You already know Java.Now explore other languages.

The language that trades Java's ceremony for expressiveness, Ruby does in one line what Java does in ten — no type declarations, no class wrappers, no boilerplate, just code that reads like English.

• No types, no compiling — variables are created on assignment; the interpreter runs scripts directly
• Blocks and iterators replace for loops — 3.times, array.each, map, select, reduce built into the language
• Modules and mixins instead of interfaces — include Comparable or Enumerable and gain 50+ methods for free
• Open classes — add methods to String, Integer, or any existing class at any time
• Pattern matching — case/in with array, hash, and type patterns, stable since Ruby 3.0

Java reimagined without the ceremony. Go keeps the static types and compiled performance Java developers expect, then strips away generics boilerplate, checked exceptions, class hierarchies, and XML config — leaving clean, readable code that deploys as a single binary.

• No classes required — functions are top-level; structs with methods replace the Java class-per-file ritual
• Goroutines — thousands of concurrent tasks at ~2 KB each; Java threads cost megabytes and require thread pools and executor services
• Error values instead of checked exceptions — (result, error) return pairs make error paths visible in the signature, not hidden in throws clauses
• Interfaces without declarations — if your type has the methods, it satisfies the interface; no implements keyword needed
• Single static binary — no JVM to install, no classpath to configure, no -jar flag; go build produces one file
• Sub-second compile times — where Java projects routinely take minutes with Gradle or Maven, a large Go codebase compiles in seconds

Shares your name and almost nothing else. Java and JavaScript both use C-family braces, and then diverge on every assumption underneath — what a class is, what this means, whether integers exist, and whether your code runs on threads.

• this is decided by the call, not the class — a detached method loses its receiver, unlike a Java method reference
• No integer type at all: every number is a double, so 7 / 2 is 3.5 and integers past 2^53 silently lose precision
• One thread and an event loop — no synchronized, no locks, no data races, and no blocking Future.get()
• class is syntax over prototypes and declares no type; any object with the right properties is accepted
• No checked exceptions, no throws clause, and a single untyped catch binding
• No method overloading — default and rest parameters do that job instead

Concise, dynamic, and dominant in data and scripting, Python trades Java's static guarantees for speed of writing — and rules data science and machine learning.

• No class or main boilerplate — a top-level print() is a whole program
• Dynamic typing and duck typing instead of declared types and interfaces
• List comprehensions in place of the stream().map().collect() pipeline
• Default and keyword arguments instead of method overloading
• No checked exceptions — nothing is declared with throws
• @dataclass as the counterpart to a Java record

Kotlin is what Java would be if it were redesigned today. Null safety in the type system, data classes in one line, extension functions instead of utility classes, when instead of switch pyramids, and coroutines instead of CompletableFuture — all on the JVM, fully interoperable with every Java library.

• Null safety baked into types — String can never be null; String? must be handled at compile time; NullPointerException becomes a compile error instead of a runtime surprise
• Data classes in one line — data class Person(val name: String, val age: Int) generates equals, hashCode, toString, and copy(); Java needs a record or 50+ lines
• Default parameters and named arguments — one function replaces a pyramid of overloads; call sites are self-documenting with connect(host = "x", ssl = true)
• Extension functions — add methods to any class without subclassing; "racecar".isPalindrome() instead of StringUtils.isPalindrome("racecar")
• Coroutines — suspend fun makes async code read like sequential code; replaces CompletableFuture chains with straightforward val result = fetchUser(42)

The JVM's guarantees, re-derived without a garbage collector. Rust replaces the GC Java developers take for granted with compile-time ownership tracking — and closes the gaps Java's null, unchecked exceptions, and type erasure leave open, catching them before the program ever runs instead of during it.

• No garbage collector at all — ownership and borrowing, tracked entirely at compile time, replace the JVM's GC as the whole memory model, not a tunable knob
• No null — absence is Option<T>, and the compiler forces you to handle it; unlike Java's opt-in Optional<T>, there is no bare nullable type left underneath to bypass it
• No exceptions — fallible functions return Result<T, E> with the ? operator for propagation, in place of Java's checked/unchecked exception hierarchy and try/catch/throws
• Traits implemented on foreign types — impl Trait for Type works even on types you don't own, something no Java interface can do without a wrapper class
• Enums are true algebraic data types — each variant carries its own payload shape, far more powerful than Java's enum even with Java 21's sealed interfaces, records, and pattern matching closing part of the gap
• Monomorphized generics, not type erasure — the compiler generates a specialized copy per type argument, so there is no runtime type-information loss the way List<String> and List<Integer> collapse into one type in the JVM

The iOS side of the mobile world, for the Android/Java developer. Swift keeps Java's static typing and OOP but bakes null-safety into the type system, favors value types over references, and replaces interfaces with protocols and extensions — familiar territory with the sharp edges filed off.

• Optionals (?) make nullability part of the type — the compiler eliminates the NullPointerException class of bug
• Structs and enums are value types (copied, not aliased), with let/var replacing final
• Enums with associated values are true sum types — what Java can only approximate with sealed interfaces
• Protocols + extensions instead of interfaces — add methods to any type, even Int, and conform existing types retroactively
• Error handling via throws/try/do-catch with no checked exceptions, plus guard let and trailing closures

The same words, and almost none of the same meanings. TypeScript checks types before the program runs, calls them interfaces and generics, and then does something you have never had to reason about: it throws the whole type system away before anything executes.

• Structural typing — a type is a shape, so an object literal satisfies an interface with no implements clause and no adapter class to write
• 🚨 Total erasure, far past Java's: no Class object, no reflection, no instanceof for an interface, and JSON.parse hands back unchecked any
• Union and literal types ("GET" | "POST") do the work of enums and sealed hierarchies without declaring a type per case
• Nullability lives in the type: under strictNullChecks a string genuinely cannot be null — the one place the checking is stricter than Java's
• Partial, Pick, keyof and mapped types compute types from other types, which Java cannot do at any level
• 🚨 One number type (a double, so 7 / 2 is 3.5), one thread, no equals/hashCode, and no checked exceptions

A modern Lisp on the JVM that replaces inheritance hierarchies with data, Clojure trades Java's mutable objects and class hierarchies for immutable persistent data structures, first-class functions, and a REPL-driven workflow.

• Immutable data structures by default — conj and assoc return new collections; the originals are never modified, eliminating the defensive copying that Java requires
• Persistent data structures use structural sharing — creating a "modified" copy is O(log n), not O(n); large collections stay efficient
• Prefix notation for all operations: (+ 1 2), (str "Hello" name), (map f coll) — the same syntax for function calls, macros, and data literals
• Sequences replace Stream chains — (->> coll (filter even?) (map #(* % 2))) is lazy by default, with no .collect(Collectors.toList()) needed
• Full Java interop on the JVM — call any Java library from Clojure; gradual adoption alongside existing Java code is practical

C# does in one line what Java does in five. Properties replace getters/setters, optional parameters replace overloads, LINQ replaces verbose Streams, and async/await replaces CompletableFuture — while staying on the same statically-typed OOP foundation Java developers already know.

• Auto-properties — public string Name { get; set; } replaces pairs of getName()/setName() methods with field-like access syntax
• Optional parameters and named arguments — no more overload pyramids for defaulted parameters; call sites are self-documenting
• LINQ with query syntax — from x in list where x > 5 select x reads like SQL and compiles to the same lazy pipeline as Java Streams, without .stream() boilerplate
• async/await as a first-class language feature — no CompletableFuture chains, no .get() blocking; async code reads like synchronous code
• No checked exceptions — method signatures stay clean; callers decide what to handle based on documentation and context, not compiler mandates

The process dies at the end of every request, and everything you know about application state is wrong. No static field survives, no pool is warm, no thread exists — and no shared mutable state can be corrupted, which is why PHP sidestepped a decade of concurrency bugs the JVM world fought. Modern PHP 8 has enums, readonly, match, named arguments and attributes; the mental image from 2009 is the thing to replace.

• A fresh interpreter per request: static fields are per-request, there is no warmup and no connection pool, and anything that must survive goes to Redis or the database
• No threads at all — no ExecutorService, no synchronized, no memory model — so concurrency is more processes, a queue worker, or Fibers under an event loop
• Declared types are checked at run time on every call, and declare(strict_types=1) makes them refuse coercion — a different trade from generics erased at compile time
• One array is List, Map and tuple at once, and it is copied on assignment, which surprises Java developers more than anything else here
• No generics in the language: @template docblocks read by PHPStan or Psalm are the ecosystem answer, and level 9 is roughly -Xlint:all taken seriously
• Enums, readonly, constructor promotion, match, named arguments and first-class callables are all here — but no records, no sealed types and no pattern matching
• Traits carry state as well as behavior, which is the line default methods deliberately do not cross
• Attributes are annotations read by reflection, and Composer is Maven with a lockfile that actually gets committed

Functional meets object-oriented on the JVM — Scala blends immutable values, powerful pattern matching, and a rich type system into a concise language that feels like the Java you always wished you had.

• val is immutable by default — final without the verbosity, and the preferred choice everywhere
• Case classes replace Java records and add pattern matching, copy, and structural equality out of the box
• Option[T] replaces null — absence is explicit in the type, not a runtime NullPointerException waiting to happen
• For comprehensions desugar into flatMap/map/filter — monadic pipelines that are more readable than Stream chains
• No static — companion objects replace static members with first-class singleton objects