My Cheatsheets

Quick Definitions (Missing Context Filled In)

Programming Lambda (C++ / Python / JavaScript): A small, anonymous function expression that can be treated as a value (passed, stored, returned). It usually closes over ("captures") variables from its surrounding scope, making it a lightweight way to create behavior inline without naming a full function.

Closure: A function plus the preserved bindings of the variables it captured from the lexical scope where it was created. Lambdas become closures when they reference outer variables.

AWS Lambda: A managed, event‑driven, serverless execution environment. You deploy a function (code + config), and AWS provisions runtime resources on demand in response to triggers (API Gateway, S3 events, queues, schedules, etc.). Execution is ephemeral; any persistence relies on external services (DynamoDB, S3, etc.).

Why this page: The word “lambda” describes two related-but-different ideas—language-level anonymous functions vs. a cloud function service. This sheet maps conceptual overlaps so the overloaded term is less confusing.

Mapping Equivalences Between C++/Python/JS Lambdas and AWS Lambda

At first glance, C++/Python/JS lambdas and AWS Lambda seem like completely different concepts, but with a little creative reasoning, we can draw some conceptual parallels.

Equivalence: Lambda as an Anonymous Function

Mapping:

• In C++/Python/JS, a lambda is a small, anonymous function.
• In AWS Lambda, a function runs independently and is called on demand.
• Both are self-contained, don’t require a named function, and are event-driven.

Equivalence: Closures and AWS Lambda State

Mapping:

• A closure in C++/Python/JS remembers variables from its surrounding scope.
• AWS Lambda doesn’t maintain state between invocations, but external storage (DynamoDB, S3, etc.) can act as “captured” variables.
• Both concepts allow functions to run statelessly but retain context externally.

Equivalence: Passing Lambdas as Callbacks vs. AWS Event Triggers

Mapping:

• C++/Python/JS lambdas are often used as callbacks (e.g., setTimeout(), event handlers).
• AWS Lambda is triggered by events (e.g., API Gateway, S3, DynamoDB updates).
• In both cases, the function does not persist but runs when triggered.

Example in JavaScript (Lambda as a Callback):

setTimeout(() => console.log("This runs later"), 2000);

Example in AWS Lambda (Triggered by API Gateway):

def lambda_handler(event, context):
    return {"statusCode": 200, "body": "Triggered by API!"}

🔹 Both execute in response to an external event.

Equivalence: Function Chaining

🔹 Mapping:

• In C++/Python/JS, you can chain functions using lambdas.
• AWS Lambda chains functions using Step Functions or EventBridge.
• In both cases, you can execute multiple functions sequentially.

Example: C++ Function Chaining

auto square = [](int x) { return x * x; };
auto increment = [](int x) { return x + 1; };
auto chain = [&](int x) { return square(increment(x)); };

std::cout << chain(4);  // (4 + 1)² = 25

Example: AWS Step Function Chaining

{
  "StartAt": "Step1",
  "States": {
    "Step1": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Function1",
      "Next": "Step2"
    },
    "Step2": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Function2",
      "End": true
    }
  }
}

In both cases, functions execute sequentially without explicit calls.

Equivalence: Memory Allocation and Cold Starts

🔹 Mapping:

• C++/Python/JS lambdas allocate memory dynamically at runtime.
• AWS Lambda functions experience cold starts when they haven’t been used recently.
• In both cases, the first execution may be slower due to initialization.

Equivalence: AWS Lambda as a Long-Lived Closure

🔹 Mapping:

• A closure stores its state by capturing variables.
• AWS Lambda doesn’t persist state directly, but DynamoDB, S3, or RDS serve as external storage.
• Both allow data persistence across function calls.

Example: Python Closure Maintaining State

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

c = make_counter()
print(c())  # 1
print(c())  # 2

Example: AWS Lambda Using DynamoDB to Store State

import boto3

dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table("CounterTable")

def lambda_handler(event, context):
    response = table.update_item(
        Key={"id": "counter"},
        UpdateExpression="SET count = if_not_exists(count, :start) + :inc",
        ExpressionAttributeValues={":start": 0, ":inc": 1},
        ReturnValues="UPDATED_NEW"
    )
    return response["Attributes"]["count"]

Both allow functions to "remember" past executions using external storage.

Final Thoughts: AWS Lambda as an Evolution of Traditional Lambdas

• C++/Python/JS lambdas → Short-lived, inline functions, often used for callbacks, filtering, and functional programming.
• AWS Lambda → A long-lived, event-driven function, triggered externally, with potential for state persistence.

🔹 Conceptual Equivalence Table

🔹 AWS Lambda is effectively a "serverless closure" with event-driven execution and external state storage.