Coding Styles

Python

Philosophy

• Readable and Simple

• Focuses on calirty and mininmal sytax

• Uses include data science, AI and scripting backend

Syntax

• Indentation defines code blocks

  • Python’s creator, Guido van Rossum, designed the language around the idea that “code should be as readable as plain English.”

• Colon (:) signals and new block of indented code (sort of like a bracket)

  • Guido van Rossum worked on a teaching language called ABC at CWI (in the Netherlands) before inventing Python. ABC used colons to introduce blocks, just like Python.

• No semicolons or braces/brackets

• Naming: snake_case

• # for comments

for i in range(1,6):
    print(f"Number {i}")

C++

Philosophy

• Power and Control

• Lowlevel access

• Manual memory management

• Performance Focuses

• Uses include systems, games, and high performace Software

Syntax

• Braces define code blocks

• Semicolons end statements

• Type declaration required

• Indentation optional but make it pretty so it is Readable

• Naming: camelCase or PascalCase

• // or /* for comments

#include <iostream>
using namespace std;
int main()
{
    for (int i = 1; i <= 5; i++)
    {
        cout << "Number " << i << endl;
    }
    return 0;
}

Javascript

Philosophy

• Dynamic and flexible

• Designed for web interactivity

• Loosely typed now supports modern modular patterns

• Uses include web apps, front end and back end

• Note that “ES6” is simply the modern version of javascript

  • ES6 added some features and changed some syntax

  • Now javascript is ES9 but everything from ES6 + is considered “modern javascript”, before ES6 is considered an older langauge

Syntax

• Similar to c++ but more flexible

• Template literals like Python f-strings

• No type declarations

• Semicolons to end statements are options but recomended

• Indentation not required but make it pretty and uniform so it is readable

• Naming: camelCase

• // or /* for comments

for (let i = 1; i <= 5; i++)
{
    console.log(`Number ${i}`)
}

Object Declaration Comparison

Feature	Python	JavaScript	C++
Typing	Dynamic	Dynamic	Static
Keyword	class	class / object literal {}	class / struct
Constructors	__init__ method	constructor() method	Class name as constructor
Access Modifier Defaults	Public	Public	Private
self / this	self explicitly passed	this implicitly available	this implicitly available
Memory Management	Automatic (garbage collected)	Automatic (garbage collected)	Manual or via smart pointers
Method Definition	Defined inside class	Defined inside class	Defined inside or outside class using ::

Python Example

class Car:
    """A simple Car class."""

    def __init__(self, make, model):
        self.make = make
        self.model = model

    def start(self):
        print(f"{self.make} {self.model} is starting.")

# Object creation
my_car = Car("Toyota", "Camry")
my_car.start()

JavaScript Example

/**
 * A simple Car class.
 */
class Car {
    constructor(make, model) {
        this.make = make;
        this.model = model;
    }

    start() {
        console.log(`${this.make} ${this.model} is starting.`);
    }
}

// Object creation
const myCar = new Car("Toyota", "Camry");
myCar.start();

C++ Example

#include <iostream>
#include <string>
using namespace std;

/**
 * @brief A simple Car class.
 */
class Car {
private:
    string make;
    string model;

public:
    // Constructor
    Car(string m, string mod) {
        make = m;
        model = mod;
    }

    // Method
    void start() {
        cout << make << " " << model << " is starting." << endl;
    }
};

// Object creation
int main() {
    Car myCar("Toyota", "Camry");
    myCar.start();
    return 0;
}

Summary Table

Concept	Python	JavaScript	C++
Define class	class ClassName:	class ClassName {}	class ClassName {}
Constructor	def __init__(self, ...)	constructor(...)	ClassName(...) {}
Create object	obj = ClassName()	const obj = new ClassName()	ClassName obj;
Instance variable access	self.attr	this.attr	this->attr
Access modifiers	Implicitly public	Implicitly public	Must specify (public, private)
Garbage collection	✅ Yes	✅ Yes	❌ Manual / Smart pointers
Documentation style	Docstring ("""...""")	JSDoc (/**...*/)	Doxygen (/**...*/)

Key Takeaways

Language	Object Philosophy
Python	Objects are flexible, lightweight, and dynamically typed. Easy for beginners.
JavaScript	Prototype-based; ES6 classes give a clean, modern OOP syntax.
C++	Deep, type-safe OOP with control over memory and performance.

Imports and Modules

Feature	Python	JavaScript (ES6)	C++
Import keyword	import module	import { name } from './file.js'	#include "file.h"
Export keyword	Functions and classes automatically accessible from modules	export / export default	Not applicable — declarations in header files
Namespace	Module namespace (each file acts as a module)	File or module-based namespace	namespace myNamespace { ... }
Encapsulation	Managed by module imports	Managed by module exports	Controlled by header / source file separation
Dependency Management	Handled via pip and virtual environments	Handled via npm or yarn	Handled manually or via build systems (CMake, Makefiles)

---

Memory and Resource Management

Aspect	Python	JavaScript	C++
Memory Management	Automatic garbage collection using reference counting	Automatic garbage collection	Manual control (stack and heap allocation)
Object Lifetime	Managed by interpreter and reference count	Managed by garbage collector	Determined by scope and destructors
Garbage Collection	Yes (reference counting + cyclic GC)	Yes (mark-and-sweep GC)	No (must free manually or use smart pointers)
Pointers	Not exposed to programmer	Not used	Directly used for memory access and manipulation
Resource Cleanup	Automatic when objects go out of scope	Automatic by GC (not deterministic)	Controlled manually or via RAII (Resource Acquisition Is Initialization)
Common Issues	Reference cycles can delay collection	Unpredictable GC timing	Memory leaks, dangling pointers if misused

Who Wins?

• Readability belongs all to python

  • It basically reads as english and is short and sweet

• Flexibility goes to Javascript

  • The syntax is flexible meaning there are many ways to achieve the same outcome

  • Semicolons are recomended but not required

  • Dynamic variable declaration with let

• Performance and Control belongs to c++

  • You can handle the memory yourself

  • It is extremly fast which is why it used for games and high end Software

  • It is so complex so that the coder can have more control over the program