F v Java.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>F# vs Java</title>
    <link rel="icon" type="image/png" href="java.png" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="description" content="A modern comparison of F# and Java, exploring syntax, typing, immutability, performance, and developer experience. This page argues why F# offers a more expressive, concise, and robust approach to solving today's software problems.">

    <style>
        :root {
            --bg: #f4f4f2;
            --panel: #ffffff;
            --accent: #4a7c59;
            --accent-light: #8fb996;
            --accent-strong: #2c5f2d;
            --text: #2e2e2e;
            --muted: #6d6d6d;
            --border: #dcdcd8;
        }

        * {
            box-sizing: border-box;
        }

        body {
            margin: 0;
            font-family: "Inter", "Segoe UI", system-ui, sans-serif;
            background: var(--bg);
            color: var(--text);
            line-height: 1.75;
        }

        header {
            background: var(--accent);
            color: #ffffff;
            padding: 3rem 1.5rem;
            text-align: center;
            box-shadow: 0 10px 25px rgba(0,0,0,0.15);
        }

        header h1 {
            margin: 0;
            font-size: 2.6rem;
            letter-spacing: 0.03em;
        }

        header p {
            max-width: 780px;
            margin: 1rem auto 0;
            font-size: 1.15rem;
        }

        main {
            max-width: 1040px;
            margin: 2.5rem auto 3.5rem;
            padding: 0 1.5rem;
        }

        section {
            background: var(--panel);
            border-radius: 14px;
            padding: 2rem 1.8rem;
            margin-bottom: 2rem;
            border: 1px solid var(--border);
            box-shadow: 0 10px 25px rgba(0,0,0,0.08);
        }

        h2 {
            margin-top: 0;
            font-size: 1.8rem;
            color: var(--accent-strong);
        }

        h3 {
            margin-top: 1.2rem;
            font-size: 1.3rem;
            color: var(--accent);
        }

        p {
            margin: 0.7rem 0;
        }

        ul, ol {
            margin-left: 1.5rem;
        }

        code {
            background: #e8efe8;
            padding: 0.2rem 0.35rem;
            border-radius: 4px;
            font-family: "Consolas", "SF Mono", Menlo, monospace;
            border: 1px solid #d0d8d0;
        }

        pre {
            background: #2c5f2d;
            color: #f4f4f2;
            padding: 1rem 1.2rem;
            border-radius: 10px;
            overflow-x: auto;
            font-size: 0.95rem;
            border: 1px solid #1f4a20;
            margin-top: 0.6rem;
        }

        pre code {
            background: transparent;
            border: none;
            padding: 0;
        }

        .compare-table {
            width: 100%;
            border-collapse: collapse;
            margin-top: 1rem;
        }

        .compare-table th,
        .compare-table td {
            padding: 0.6rem 0.7rem;
            border-bottom: 1px solid var(--border);
        }

        .compare-table th {
            text-align: left;
            background: #f0f0ed;
            color: var(--accent-strong);
        }

        .compare-table td.label {
            color: var(--muted);
            width: 26%;
        }

        footer {
            background: var(--accent-light);
            color: #ffffff;
            text-align: center;
            padding: 1.6rem;
            font-size: 0.9rem;
            border-top: 1px solid var(--accent);
        }
    </style>
</head>

<body>
<header>
    <h1>F# vs Java</h1>
    <p>
        A modern comparison of two influential languages — one rooted in functional clarity, the other in classical
        object-oriented design. This page argues why F# offers a more expressive, concise, and robust approach to
        solving today’s software problems.
    </p>
</header>

<main>

    <section>
        <h2>Introduction</h2>
        <p>
            Java and F# both run on mature, industrial-strength runtimes. Java runs on the JVM; F# runs on .NET. Both
            have excellent tooling, large ecosystems, and long histories in enterprise software. But they represent
            fundamentally different ways of thinking.
        </p>
        <p>
            Java is class-based, object-oriented, and verbose by design. It emphasises explicit structure, inheritance,
            and mutable objects. F#, by contrast, is functional-first, expression-oriented, and concise. It emphasises
            immutability, algebraic data types, and composable functions.
        </p>
        <p>
            In this comparison, we will explore how these differences affect readability, correctness, performance,
            domain modelling, and developer experience — and why F# often provides a cleaner, more expressive solution
            to modern software challenges.
        </p>
    </section>

    <section>
        <h2>Syntax and expressiveness</h2>
        <p>
            Let’s begin with a simple example: computing the sum of squares of a list of numbers.
        </p>

        <h3>F#: concise and functional</h3>
        <pre><code>let numbers = [1; 2; 3; 4; 5]

let sumOfSquares nums =
    nums
    |> List.map (fun n -> n * n)
    |> List.sum

printfn "%d" (sumOfSquares numbers)</code></pre>

        <p>
            F# expresses the idea directly: transform the list, then sum it. No boilerplate. No classes. No ceremony.
        </p>

        <h3>Java: verbose and object-oriented</h3>
        <pre><code>import java.util.*;

public class Main {
    public static void main(String[] args) {
        List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 3, 4, 5);

        int result = numbers.stream()
                            .map(n -> n * n)
                            .reduce(0, Integer::sum);

        System.out.println(result);
    }
}</code></pre>

        <p>
            Java’s version is longer, requires imports, classes, and boilerplate. Java Streams bring functional ideas
            into Java, but they are bolted onto an object-oriented foundation rather than built into the language.
        </p>

        <p><strong>Advantage: F#</strong> — clearer, shorter, and closer to the underlying idea.</p>
    </section>

    <section>
        <h2>Typing and correctness</h2>
        <p>
            Both languages are statically typed, but F#’s type system is significantly more expressive.
        </p>

        <table class="compare-table">
            <tr>
                <th>Aspect</th>
                <th>F#</th>
                <th>Java</th>
            </tr>
            <tr>
                <td class="label">Typing style</td>
                <td>Static, with powerful inference.</td>
                <td>Static, verbose, requires explicit generics.</td>
            </tr>
            <tr>
                <td class="label">Domain modelling</td>
                <td>Discriminated unions, records, pattern matching.</td>
                <td>Classes, interfaces, enums.</td>
            </tr>
            <tr>
                <td class="label">Error detection</td>
                <td>Many errors caught at compile time.</td>
                <td>Also compile-time, but less expressive modelling.</td>
            </tr>
        </table>

        <h3>F#: algebraic data types</h3>
        <pre><code>type Payment =
    | Cash of amount : decimal
    | Card of number : string * expiry : string
    | BankTransfer of iban : string</code></pre>

        <p>
            This is expressive, safe, and forces exhaustive handling. Java cannot express this structure cleanly without
            multiple classes, interfaces, and boilerplate.
        </p>

        <h3>Java: class hierarchies</h3>
        <pre><code>abstract class Payment {}

class Cash extends Payment {
    public BigDecimal amount;
}

class Card extends Payment {
    public String number;
    public String expiry;
}

class BankTransfer extends Payment {
    public String iban;
}</code></pre>

        <p>
            Java’s version is longer, more error-prone, and requires more ceremony. Pattern matching in Java is improving
            (Java 21+), but it still lacks the elegance and safety of F#’s discriminated unions.
        </p>

        <p><strong>Advantage: F#</strong> — dramatically better domain modelling.</p>
    </section>

    <section>
        <h2>Immutability and functional style</h2>
        <p>
            F# is immutable by default. Java is mutable by default.
        </p>

        <h3>Why immutability matters</h3>
        <ul>
            <li>Fewer bugs caused by shared state.</li>
            <li>Easier reasoning about code.</li>
            <li>Better concurrency safety.</li>
            <li>Clearer data flow.</li>
        </ul>

        <p>
            Java developers often need defensive copying, synchronisation, or complex concurrency tools. F# developers
            often do not.
        </p>

        <p><strong>Advantage: F#</strong> — safer defaults and cleaner concurrency.</p>
    </section>

    <section>
        <h2>Performance</h2>
        <p>
            Both languages run on high-performance runtimes (JVM vs .NET). In practice:
        </p>

        <ul>
            <li>Java is extremely fast for long-running server applications.</li>
            <li>F# is extremely fast for numerical, financial, and functional workloads.</li>
            <li>.NET’s JIT and GC are competitive with the JVM.</li>
        </ul>

        <p>
            Performance differences are usually negligible compared to differences in expressiveness and correctness.
        </p>

        <p><strong>Advantage: Tie</strong> — both runtimes are excellent.</p>
    </section>

    <section>
        <h2>Developer experience</h2>
        <p>
            F# developers often describe the language as “pleasant,” “expressive,” and “freeing.” Java developers often
            describe the language as “reliable,” “structured,” and “verbose.”
        </p>

        <h3>F# developer experience highlights</h3>
        <ul>
            <li>Minimal boilerplate.</li>
            <li>Concise syntax.</li>
            <li>Powerful type inference.</li>
            <li>Pattern matching everywhere.</li>
            <li>Functional pipelines.</li>
        </ul>

        <h3>Java developer experience highlights</h3>
        <ul>
            <li>Huge ecosystem.</li>
            <li>Stable, predictable tooling.</li>
            <li>Strong OOP foundations.</li>
            <li>Verbose but explicit code.</li>
        </ul>

        <p>
            Java is dependable. F# is elegant. For many developers, elegance wins.
        </p>

        <p><strong>Advantage: F#</strong> — faster to write, easier to read, harder to break.</p>
    </section>

    <section>
        <h2>Conclusion: why F# often wins</h2>
        <p>
            Java is a proven, industrial-strength language. It powers enormous systems worldwide. But its design is
            rooted in the 1990s: classes, inheritance, mutable objects, and verbose syntax.
        </p>
        <p>
            F# represents a more modern approach:
        </p>
        <ul>
            <li>Functional-first.</li>
            <li>Immutable by default.</li>
            <li>Concise and expressive.</li>
            <li>Algebraic data types.</li>
            <li>Pattern matching.</li>
            <li>Powerful type inference.</li>
        </ul>
        <p>
            These features make F# particularly strong for:
        </p>
        <ul>
            <li>Finance and quantitative modelling.</li>
            <li>Complex business logic.</li>
            <li>Backend services.</li>
            <li>Scientific computing.</li>
            <li>Any domain where correctness matters.</li>
        </ul>

        <p>
            Java is a good language. F# is a better one for many modern problems — especially when clarity, correctness,
            and expressiveness are priorities.
        </p>

        <p><strong>Final verdict: F# offers a cleaner, more powerful way to think about software.</strong></p>
    </section>

</main>

<footer>
    <p>This blog is part of a series comparing <a href="Fintro.html">F#</a> with other programming languages.  See also <a href="F v Python.html">F# vs Python</a>.</p>
    <p>&copy; <span id="year"></span> F# vs Java</p>
</footer>

<script>
    document.getElementById("year").textContent = new Date().getFullYear();
</script>

</body>
</html>