Comparing JavaScript, Java, Python, C, and C++ Through Code

Programming languages are the tools through which we communicate with machines. Each language embodies a different philosophy, trade-off, and design goal. In this course section, we compare five of the most influential programming languages — JavaScript, Java, Python, C, and C++ — by writing the same programs in each, analyzing syntax differences, performance characteristics, and ecosystem strengths.

The five languages span a wide spectrum of abstraction levels, from bare-metal systems programming (C/C++) to high-level scripting (Python/JS), with Java occupying a middle ground. Understanding these differences is critical for choosing the right tool for any given problem.

At a high level, the key distinctions are:

Hello World Comparison

The simplest program reveals the most about a language's verbosity, boilerplate, and entry-point conventions:

C:

1#include <stdio.h>
2int main() {
3    printf("Hello, World!\n");
4    return 0;
5}

C++:

1#include <iostream>
2int main() {
3    std::cout << "Hello, World!" << std::endl;
4    return 0;
5}

Java:

1public class HelloWorld {
2    public static void main(String[] args) {
3        System.out.println("Hello, World!");
4    }
5}

Python:

1print("Hello, World!")

JavaScript:

1console.log("Hello, World!");

Notice how C/C++/Java all require explicit main entry points and boilerplate, while Python and JavaScript distill the operation to a single line. Java's class-centric design mandates that even a trivial script must be wrapped in a class.

Factorial — Recursion Across Languages

A recursive factorial implementation highlights how each language handles functions, conditionals, and numeric types:

Python (uses arbitrary-precision integers — no overflow):

1def factorial(n):
2    if n <= 1:
3        return 1
4    return n * factorial(n - 1)
5
6print(factorial(100))

C (fixed-width — will overflow for large $n$):

1long long factorial(int n) {
2    if (n <= 1) return 1;
3    return n * factorial(n - 1);
4}

Java (uses BigInteger for arbitrary precision):

1import java.math.BigInteger;
2
3static BigInteger factorial(int n) {
4    if (n <= 1) return BigInteger.ONE;
5    return BigInteger.valueOf(n).multiply(factorial(n - 1));
6}

JavaScript (uses BigInt for large integers):

1function factorial(n) {
2    if (n <= 1n) return 1n;
3    return BigInt(n) * factorial(n - 1n);
4}

C++ (similar to C, but can use boost::multiprecision):

1long long factorial(int n) {
2    if (n <= 1) return 1;
3    return n * factorial(n - 1);
4}

Object-Oriented Programming Comparison

All five languages support some form of OOP, but the implementation details differ dramatically. Below we create a simple Dog class with a speak method:

C does not have native OOP support — you can simulate it with structs and function pointers, but it's manual and error-prone. C++ was designed to bring OOP to C, while Java makes everything an object. Python offers flexible OOP with duck typing, and JavaScript uses a unique prototypal inheritance model (though ES6 class syntax provides a familiar wrapper).

Memory Model Deep Dive

C/C++ Memory Model:

• Stack allocation for local variables (fast, automatic).
• Heap allocation via malloc/free (C) or new/delete (C++).
• C++ introduces RAII, where destructors automatically free resources when objects go out of scope.
• No garbage collector overhead, but full responsibility on the programmer.

Java Memory Model:

• All objects live on the heap; primitives on the stack.
• Generational garbage collector (G1GC, ZGC, Shenandoah).
• finalize() (deprecated) → Cleaner API for cleanup.

Python Memory Model:

• Everything is an object (even int!), stored on the heap.
• Reference counting + cyclic garbage collector.
• GIL (Global Interpreter Lock) limits true parallelism.

JavaScript (V8) Memory Model:

• Objects on the heap; primitives may be on stack.
• Orinoco garbage collector (concurrent, parallel, incremental).
• No manual control over memory reclamation.

Error Handling Comparison

How each language deals with failure shapes every program you write:

C has no exception mechanism. Errors are communicated via return values (e.g., NULL, -1) and the global errno. C++ added exceptions but many codebases (Google's, game engines) ban them for performance reasons. Java uniquely enforces checked exceptions. Python uses exceptions for everything — even for-loop termination uses StopIteration. JavaScript uses exception handling similar to Java but without checked exceptions.

Concurrency Models

Modern computing demands parallel execution. Each language takes a fundamentally different approach:

Sorting Algorithm — Full 5-Language Implementation

As a final comprehensive example, here is QuickSort implemented in all five languages. This showcases array handling, recursion, partitioning, and function definition patterns:

Algorithm recap: QuickSort selects a pivot, partitions the array around it, then recursively sorts the sub-arrays. Average time complexity: $O(n \log n)$; worst case: $O(n^2)$.