C++ & JavaScript

1. Low-Level Memory Management & Pointers (C++)

C++ gives you direct control over memory using pointers. A pointer stores the memory address of a variable instead of its value. You access the address with the & operator and the value through the pointer using *. This is essential for writing fast, resource-efficient programs — especially on constrained devices.

• A pointer is declared as int* ptr = &x; — it "points to" the location of x.
• Use & to get the address of a variable; use * to get the value at that address (dereferencing).
• Pointers let you work directly with hardware, manage dynamic memory, and optimize for speed.
• Compile C++ code with GCC/G++ in your terminal or use VS Code with the C++ extension.

💡 Practical Skill: Efficient resource management is critical for systems programming, game engines, and embedded devices. Use VS Code and the GCC/G++ compiler to build and test your C++ programs.

#include <iostream>
using namespace std;

int main() {
    int score = 85;
    int* ptr = &score;   // ptr holds the memory address of score

    cout << "Value of score: " << score << endl;
    cout << "Address of score: " << ptr << endl;
    cout << "Value at address (dereference): " << *ptr << endl;

    *ptr = 95;           // change score through the pointer
    cout << "New score: " << score << endl;

    return 0;
}

2. Asynchronous Programming & Event Loops (JavaScript)

JavaScript is single-threaded — it can only do one thing at a time. But thanks to the Event Loop, it can handle slow operations (like fetching data from an API) without freezing the UI. Modern JavaScript uses async/await to write clean, readable asynchronous code.

• The Event Loop checks a queue of pending tasks and runs them one by one when the main thread is free.
• async function returns a Promise; await pauses execution until the Promise resolves.
• Use Chrome DevTools to inspect network requests and debug async code in the console.
• Node.js uses the same Event Loop for server-side async I/O — perfect for building fast APIs.

💡 Practical Skill: Build interactive web apps that fetch data without lag, or write Node.js scripts that handle many users at once. Debug with Chrome DevTools and run with Node.js.

// Simulates fetching user data from an API
function fetchUser(id) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ id, name: "Student " + id, course: "C++ & JavaScript" });
    }, 1500); // simulates 1.5s network delay
  });
}

async function loadUser() {
  console.log("Fetching user data...");
  const user = await fetchUser(101);
  console.log("User loaded:", user);
  // Output after ~1.5s:
  // { id: 101, name: "Student 101", course: "C++ & JavaScript" }
}

loadUser();
console.log("This logs immediately — UI is not frozen!");

3. Object-Oriented vs. Functional Programming

OOP (Object-Oriented Programming) groups data and behavior into classes (common in C++). Functional Programming (FP) uses pure functions and avoids changing state — modern JavaScript embraces FP with methods like .map(), .filter(), and .reduce(). Both paradigms help you write clean, maintainable code.

• C++ OOP: create a class with properties and methods, then instantiate objects.
• JavaScript FP: use .map() to transform arrays without modifying the original — this is immutability.
• Choose OOP when modeling real-world entities (a Car, a Student); choose FP for data transformations.
• Many modern projects use both — C++ for performance-critical objects, JavaScript for flexible data pipelines.

💡 Practical Skill: Use VS Code for both C++ and JavaScript. In C++, write classes for structured systems. In JavaScript, chain functional methods for data processing.

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

class NumberProcessor {
public:
    vector<int> numbers;

    NumberProcessor(vector<int> nums) : numbers(nums) {}

    vector<int> getDoubled() {
        vector<int> result;
        for (int n : numbers) {
            result.push_back(n * 2);
        }
        return result;
    }
};

int main() {
    NumberProcessor np({1, 2, 3, 4, 5});
    vector<int> doubled = np.getDoubled();

    for (int n : doubled) cout << n << " ";
    // Output: 2 4 6 8 10
    return 0;
}

const numbers = [1, 2, 3, 4, 5];

// Pure function: does NOT change the original array
const doubled = numbers.map(n => n * 2);

console.log(doubled);
// Output: [2, 4, 6, 8, 10]
console.log(numbers); // Original unchanged: [1, 2, 3, 4, 5]

4. Modern ES6+ Scripting Standards

Modern JavaScript (ES6 and beyond) introduces features that make code cleaner, safer, and more expressive. Arrow functions (=>) provide a shorter syntax, template literals (backticks ` `) let you embed variables in strings, and destructuring extracts values from objects or arrays in one line.

• Arrow functions: const add = (a, b) => a + b; — no need for function keyword.
• Template literals: `Hello, ${name}!` — much cleaner than string concatenation.
• Destructuring: const { name, age } = user; — extract fields in one step.
• These features are fully supported in all modern browsers and Node.js in 2026.

💡 Practical Skill: Write concise, readable code for both browser and Node.js environments. Debug with Chrome DevTools Sources panel.

// Arrow function
const greet = (name) => `Welcome to Rescue Academy, ${name}!`;

// Object with destructuring
const student = { name: "John", age: 20, city: "Juba" };
const { name, city } = student;

// Template literal with embedded expression
const message = `
  Student: ${name}
  City: ${city}
  Greeting: ${greet(name)}
`;

console.log(message);
// Output:
//   Student: John
//   City: Juba
//   Greeting: Welcome to Rescue Academy, John!

5. Hardware Interfacing & Performance

C++ is the language of choice for high-performance and hardware-level programming — it runs on microcontrollers, game engines, and operating systems. JavaScript (Node.js) handles the server-side: file systems, network requests, and lightweight background tasks. Together, they cover everything from sensor data to web APIs.

• C++ compiles directly to machine code — no interpreter, maximum speed.
• Use C++ for resource-constrained devices (IoT sensors, Raspberry Pi, embedded systems).
• Node.js uses the V8 engine to run JavaScript on servers — great for handling many concurrent connections.
• Both languages are essential for full-stack development: C++ in the backend engine, JavaScript on the web layer.

💡 Practical Skill: Optimize C++ code for resource-constrained systems and build Node.js scripts for data processing. Use VS Code for both — install the C++ extension and Node.js runtime.

#include <iostream>
using namespace std;

class TemperatureSensor {
private:
    double currentTemp;

public:
    TemperatureSensor() : currentTemp(25.0) {}

    void readSensor() {
        // Simulate a fluctuating sensor reading
        currentTemp += (rand() % 10 - 5) * 0.5;
        if (currentTemp < -10) currentTemp = -10;
        if (currentTemp > 50) currentTemp = 50;
    }

    double getTemperature() { return currentTemp; }
};

int main() {
    TemperatureSensor sensor;
    for (int i = 0; i < 5; i++) {
        sensor.readSensor();
        cout << "Reading " << i+1 << ": "
             << sensor.getTemperature() << "°C" << endl;
    }
    return 0;
}

// Simulate checking if a server is healthy
const http = require("http");

const server = http.createServer((req, res) => {
  if (req.url === "/health") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ status: "OK", uptime: process.uptime() }));
  } else {
    res.writeHead(404);
    res.end("Not Found");
  }
});

server.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
  console.log('Try: curl http://localhost:3000/health');
});

Quick Quiz — C++ & JavaScript Basics