The Halting Problem proves that no algorithm can determine whether every arbitrary program will terminate. Explore the Barber Paradox, Russell's Paradox, self-reference, diagonalisation, and Alan Turing's elegant proof of undecidability.

The Halting Problem: Paradoxes, Self-Reference, and Why Some Problems Are Impossible to Solve

1. What Is a Paradox?

2. The Barber Paradox: Who Shaves the Barber?

The barber shaves all and only those men in the village who do not shave themselves.

Case A: The Barber Shaves Himself

Case B: The Barber Does Not Shave Himself

If the barber shaves himself, he must not shave himself. If the barber does not shave himself, he must shave himself.

3. The Liar Paradox: This Statement Is False

This statement is false.

Case A: The Statement Is True

Case B: The Statement Is False

If the statement is true, it is false. If the statement is false, it is true.

4. Russell's Paradox: The Set That Cannot Exist

R = { x | x is a set and x is not an element of x }

Case A: R Contains Itself

Case B: R Does Not Contain Itself

R contains R if and only if R does not contain R.

5. The Halting Problem: Can We Predict Whether a Program Will Finish?

def program_a():
    print("Hello, World!")

def program_b():
    while True:
        pass

Formal Definition

halts(program, input)

True   # The program eventually terminates
False  # The program runs forever

• Universality: It works for every valid program and every valid input in the computational model.
• Correctness: It always returns the correct answer.
• Termination: The halts function must itself terminate in finite time.

6. Proving the Halting Problem Is Undecidable

Step 1: Assume a Perfect Halting Checker Exists

def halts(program, input):
    # Always returns True if program(input)
    # eventually terminates.
    #
    # Always returns False if program(input)
    # runs forever.
    #
    # This function always terminates.
    ...

Step 2: Construct a New Program That Does the Opposite

def paradox(program):
    if halts(program, program):
        while True:
            pass
    else:
        return

halts(program, program)

Step 3: Call the Function With Itself

paradox(paradox)

Case A: halts(paradox, paradox) Returns True

while True:
    pass

Case B: halts(paradox, paradox) Returns False

return

Step 4: The Contradiction

If halts predicts termination, paradox runs forever. If halts predicts nontermination, paradox terminates.

7. Why Is This Called Undecidability?

8. Is the Halting Problem Actually a Paradox?

9. Connection to Cantor's Diagonal Argument

10. Why Can't We Just Simulate the Program?

Why not simply run the program and observe whether it terminates?

def very_slow_program():
    for i in range(10**100):
        pass
    return

11. Could AI Solve the Halting Problem?

12. Beyond the Halting Problem: Rice's Theorem

Does this arbitrary program compute a function that always returns zero? Does this arbitrary program compute a function that is defined for every possible input? Does this arbitrary program compute exactly the same function as a given reference program?

13. What Does This Mean for Software Engineering?

14. Final Thoughts: The Limits of Computation

If a universal algorithm could always predict whether any program halts, we could construct a program that deliberately contradicts its prediction.

References and Further Reading

• The Halting Problem — Wikipedia
• The Barber Paradox — Wikipedia
• The Liar Paradox — Wikipedia
• Russell's Paradox — Wikipedia
• Diagonal Argument — Wikipedia
• Rice's Theorem — Wikipedia
• Alan Turing (1936), On Computable Numbers, with an Application to the Entscheidungsproblem

Download / Install the “Image Nine-Grid” Shortcut

• Click here to install: Image Nine-Grid (iCloud)
• Local Download - iOS Shortcut to Cut a Picture into 3x3

You Can Also Share a .shortcut File Directly

.shortcut

Image Nine-Grid.shortcut

What Exactly Is a .shortcut File?

AEA1

.shortcut
│
└── AEA1 Signed Archive
    │
    └── Apple Archive
        │
        └── Shortcut.wflow
            │
            └── Binary Property List
                │
                ├── Workflow metadata
                ├── Shortcut icon
                ├── Input / output types
                └── WFWorkflowActions
                    └── Individual shortcut actions

What Does This Shortcut Actually Do?

┌─────────────────┐
│                 │
│                 │
│   Original      │
│     Photo       │
│                 │
│                 │
└─────────────────┘

┌─────┬─────┬─────┐
│  1  │  2  │  3  │
├─────┼─────┼─────┤
│  4  │  5  │  6  │
├─────┼─────┼─────┤
│  7  │  8  │  9  │
└─────┴─────┴─────┘

4032 × 3024

1344 × 1008

Creating the “Image Nine-Grid” Shortcut from Scratch

Step 1: Create a New Shortcut

Shortcuts
→ All Shortcuts
→ +

Image Nine-Grid

Step 2: Support Two Ways of Providing the Image

Open Shortcuts
→ Tap “Image Nine-Grid”
→ Select Photo

Photos
→ Select a photo
→ Share
→ Image Nine-Grid

Receive Images from Share Sheet

If Shortcut Input has any value

    Set variable img to Shortcut Input

Otherwise

    Select Photos

    Set variable img to Photos

End If

if shortcut_input:
    img = shortcut_input
else:
    img = select_photo()

img

Step 3: Get the Image Width and Height

Width
Height

4032 × 3024

tileWidth = Width / 3
tileHeight = Height / 3

Width = 4032
Height = 3024

tileWidth = 4032 / 3
          = 1344

tileHeight = 3024 / 3
           = 1008

1344 × 1008

Step 4: Calculate the Position of All Nine Images

(0, 0)

tileWidth
tileHeight

Position = Custom

tileWidth

tileHeight

A Cleaner Version: Use Two Repeat Loops

for row in range(3):
    for col in range(3):
        x = col * tileWidth
        y = row * tileHeight

        crop(
            x=x,
            y=y,
            width=tileWidth,
            height=tileHeight
        )

Repeat 3 Times

row = Repeat Index - 1

Repeat 3 Times

column = Repeat Index - 1

X = column × tileWidth
Y = row × tileHeight

Crop img

Position = Custom
X Coordinate = X
Y Coordinate = Y
Width = tileWidth
Height = tileHeight

gridImages

gridImages

Step 5: Save the Nine Images

gridImages

Complete Shortcut Command Flow

1. Receive Images from Share Sheet


2. If Shortcut Input has any value

       Set variable img = Shortcut Input

   Otherwise

       Select Photos
       Set variable img = Photos

   End If


3. Get Width of img

       → width


4. Get Height of img

       → height


5. Calculate

       tileWidth = width / 3


6. Calculate

       tileHeight = height / 3


7. Repeat 3 Times

       row = Repeat Index - 1

       Repeat 3 Times

           column = Repeat Index - 1

           X = column × tileWidth
           Y = row × tileHeight

           Crop img

               Position = Custom
               X Coordinate = X
               Y Coordinate = Y
               Width = tileWidth
               Height = tileHeight

           Add cropped result to gridImages

       End Repeat

   End Repeat


8. Save gridImages to Photo Album

• Input
• Variables
• If / Else
• Nested Loops
• Arithmetic
• Coordinate Calculations
• Image Processing
• Output

What Would the Same Thing Look Like in Python?

pip install pillow

from pathlib import Path
from PIL import Image, ImageOps


def make_nine_grid(input_file: str, output_dir: str = "nine_grid"):
    input_path = Path(input_file)
    output_path = Path(output_dir)

    output_path.mkdir(parents=True, exist_ok=True)

    # Open the image
    image = Image.open(input_path)

    # Correct orientation using EXIF metadata
    image = ImageOps.exif_transpose(image)

    width, height = image.size

    # -------------------------
    # Step 1: Calculate 3 × 3 boundaries
    # -------------------------
    #
    # Divide the width into three columns
    # and the height into three rows.
    #
    # There is no need to crop the source
    # image into a square first.
    #
    # Calculating boundaries this way also
    # handles dimensions that are not exactly
    # divisible by 3 without losing pixels.
    #

    x = [
        0,
        width // 3,
        width * 2 // 3,
        width,
    ]

    y = [
        0,
        height // 3,
        height * 2 // 3,
        height,
    ]

    # -------------------------
    # Step 2: Crop into nine images
    # -------------------------

    index = 1

    for row in range(3):
        for col in range(3):

            box = (
                x[col],
                y[row],
                x[col + 1],
                y[row + 1],
            )

            tile = image.crop(box)

            filename = output_path / f"grid_{index:02}.png"

            tile.save(filename)

            print(
                f"{index}: "
                f"row={row}, "
                f"col={col}, "
                f"box={box}, "
                f"size={tile.size}"
            )

            index += 1


if __name__ == "__main__":
    make_nine_grid(
        "photo.jpg",
        "nine_grid",
    )

python nine_grid.py

nine_grid/
├── grid_01.png
├── grid_02.png
├── grid_03.png
├── grid_04.png
├── grid_05.png
├── grid_06.png
├── grid_07.png
├── grid_08.png
└── grid_09.png

One Small but Important Detail in the Python Version

4032 × 3024

4032 / 3 = 1344
3024 / 3 = 1008

1344 × 1008

4033 × 3025

4033 / 3 = 1344.333...
3025 / 3 = 1008.333...

0.333 pixels

tileWidth = width // 3
tileHeight = height // 3

tileWidth = 1344
tileHeight = 1008

1344 × 3 = 4032
1008 × 3 = 3024

x0 = 0
x1 = width // 3
x2 = width * 2 // 3
x3 = width

y0 = 0
y1 = height // 3
y2 = height * 2 // 3
y3 = height

width = 4033

0
1344
2688
4033

0    → 1344
1344 → 2688
2688 → 4033

Why Is There No Need to Crop the Image into a Square?

3 Columns × 3 Rows

4032 × 3024

4 : 3

1344 × 1008

4 : 3

4032 × 3024

3024 × 3024

4032 - 3024
= 1008 pixels

How Do I Use the Shortcut?

Shortcuts
→ Image Nine-Grid
→ Select Photo

Photos
→ Open a photo
→ Share
→ Image Nine-Grid

Shortcut Input

Why I Prefer a Shortcut Instead of a Nine-Grid App

3 × 3

2 × 2

4 × 4

Ask for Input

Enter N:

tileWidth = width / N
tileHeight = height / N

for row in range(N):
    for col in range(N):

x[i] = width * i // N
y[i] = height * i // N

i = 0, 1, 2, ..., N

Shortcuts Is Really a Form of Programming

Input
Variables
If / Else
Loops
Nested Loops
Arithmetic
Coordinates
Image Processing
Output

for row in range(3):
    for col in range(3):

        left   = width * col // 3
        right  = width * (col + 1) // 3

        top    = height * row // 3
        bottom = height * (row + 1) // 3

        crop(
            left,
            top,
            right,
            bottom,
        )

Photos
→ Share
→ Image Nine-Grid

Hackathon Usually Lasts Just One Week

Fake It Until You Make It

Sometimes the Idea Matters More Than the Delivery

This Year I Joined Two Projects

There Are Also T-Shirts, SWAG and a Lunch Voucher

You Do Not Have to Win

One Week of “Legitimate Tinkering”

The Idea Matters More Than the Result

Remembering the Days of VB and Delphi

VB6’s Convenience and the Cost of Moving On

Can One Technology Really Last an Entire Career?

Will AI Make RAD Obsolete?

From Dragging Controls to Directing Multiple Agents

Once AI Writes the Code, Who Understands and Reviews It?

Easier Than Assembly Is a Very Low Bar

A Human in the Loop Must Do More Than Click Approve

Our Output Is Growing Faster Than Our Experience

Making Time to Understand

From Stack Overflow to Asking AI Directly

AI Began to Gain “Eyes”, “Ears”, and “Hands”

From Explaining Coding Problems to Contributing to Mathematical Research

Remarkable Progress Still Requires Precise Reporting

From Vibe Coding to Harness Engineering

Turning Ideas into Software Through Natural Language

Helping AI Work Reliably and Consistently

Will English Be the Programming Language of the Future?

Expressing Requirements Clearly Is a Skill

• Are we reducing average latency or improving P99 latency?
• Are we increasing throughput or reducing costs?
• Can the interface change?
• How much accuracy, if any, can we sacrifice?
• How will we establish whether the change actually helped?

You Can Delegate Code Generation, but You Still Need to Develop Your Judgement

The Ability to Read Code

Domain Expertise

Software Engineering Skills

Yesterday’s Wonders Are Becoming Today’s Default Expectations

A Google Alert Woke Me Up: Postmortem of a WordPress Security Incident

How the incident happened?

1. The attacker exploited a publicly known WordPress or plugin vulnerability to access data that should not have been readable.
2. This exposed a Cloudflare credential stored by a plugin in the WordPress database.
3. The attacker used the credential to modify Cloudflare configuration and deploy an unauthorised Worker.
4. The malicious Worker intercepted selected blog requests before they reached my origin server.
5. Some legitimate pages were replaced with Indonesian-language gambling content.
6. By controlling the content returned for the domain, the attacker completed Google Search Console ownership verification.
7. Google’s “new owner added” email finally alerted me to the compromise.

Timeline of the incident

• July 2026: A security issue affecting the older WordPress or plugin combination was publicly disclosed, followed by a patched release. I did not upgrade immediately, creating a window of exposure.
• Mid-to-late July 2026: The server logs showed increasing automated probes against WordPress and common plugin endpoints. Public servers receive this kind of scanning every day, so scanning alone does not prove a successful compromise.
• Late July to early August 2026: Requests appeared for known vulnerable paths, upload locations, and suspicious script names. Most returned “not found,” but they showed that automated attack systems were continuously testing the site.
• Early August 2026: The attacker likely used the unpatched vulnerability to access sensitive plugin configuration. The evidence supports database-secret disclosure more strongly than a successful WordPress dashboard login.
• Shortly afterwards: The exposed Cloudflare credential was used to add or modify edge-side logic. Selected blog pages began being replaced before the requests reached the origin server.
• During the same period: Hijacked pages displayed Indonesian-language gambling promotions, apparently for SEO poisoning and traffic redirection.
• 11 August 2026: By controlling the website response, the attacker completed Google Search Console verification and added an unknown identity as a verified site owner.
• 11 August 2026: I received Google’s ownership notification and immediately began incident response.
• 11–12 August 2026: I removed the unauthorised Google owner, inspected and removed suspicious Cloudflare Workers and configuration, and revoked and rotated potentially exposed credentials.
• 12 August 2026: I upgraded the affected WordPress installations and inspected administrator accounts, database privileges, web logs, file timestamps, scheduled tasks, and common WebShell indicators.
• 12 August 2026: I removed sensitive plugin configuration left in the database and began restricting MySQL filesystem capabilities.
• 12 August 2026: I added a rule preventing PHP execution inside WordPress upload directories while reviewing the Apache configuration and service state.
• Ongoing: I am continuing to review filesystem permissions, backup recoverability, Cloudflare token permissions, and the core, theme, and plugin versions used by the remaining WordPress installations.

What the attacker did

• Obtained a credential capable of calling the Cloudflare API.
• Added or modified Cloudflare edge-side execution logic.
• Intercepted selected WordPress page requests before they reached the origin server.
• Returned gambling promotional content to visitors or search engines.
• Added an unauthorised owner to Google Search Console.
• Attempted to exploit the domain’s existing reputation and rankings for SEO poisoning and traffic redirection.

Did the attacker log in to the WordPress dashboard?

Did the attacker gain access to the server filesystem?

Were the WebShell probes related to this vulnerability?

• Arbitrary file upload.
• Arbitrary file write.
• Remote code execution.
• Compromised WordPress dashboard access.
• Permission to install a malicious plugin.
• Another vulnerable component providing code execution.

Were MySQL usernames or passwords exposed?

Why did Cloudflare not stop the attack?

Why does WordPress store secrets in the database?

• Avoid giving WordPress plugins high-privilege infrastructure credentials.
• Create separate tokens for each site and purpose.
• Restrict every token to only the required resources and operations.
• Use expiry dates and rotate credentials regularly.
• Delete unused plugins instead of merely deactivating them.
• Treat database backups as sensitive data.
• Monitor token usage, Worker changes, and ownership changes.
• Revoke credentials when the plugin that used them is removed or disabled.

What I did after discovering the incident

1. Removed the unauthorised Google Search Console owner.
2. Removed unauthorised Cloudflare Workers and related configuration.
3. Revoked and regenerated potentially exposed API tokens.
4. Upgraded the affected WordPress installations.
5. Updated plugins and themes and removed unused components.
6. Inspected WordPress administrator accounts, application passwords, and suspicious sessions.
7. Removed sensitive plugin settings left in the database.
8. Restricted the WordPress database account’s privileges.
9. Disabled unnecessary MySQL local-file import functionality. Linux Disk Space Troubleshooting: Find Large Files and Directories with ncdu
10. Disabled or tightly constrained MySQL server-side file access.
11. Reviewed web logs, system logs, scheduled tasks, and suspicious files.
12. Disabled PHP execution inside WordPress upload directories.
13. Began reviewing owners, groups, and permissions across all website files.
14. Checked whether existing backups were complete and recoverable, not merely whether backup files existed.
15. Rotated administrator passwords, database passwords, and WordPress authentication keys and salts.

Why disable PHP execution in the uploads directory?

Revisiting filesystem permissions

• Application code should normally be owned by a deployment or administrative account.
• The web-server account should be able to read code but should not own the entire site.
• Write access should be granted only to upload, cache, or temporary directories that genuinely require it.
• Configuration files should use stricter permissions.
• The entire site should not be writable by the web-server account merely for convenience.
• Temporary troubleshooting permissions must not become permanent.
• Writable directories should not also execute server-side scripts wherever possible.

• Review and apply WordPress security updates promptly.
• Update plugins and themes at the same time.
• Remove disabled, abandoned, or unnecessary plugins.
• Avoid blindly enabling automatic major-version upgrades everywhere.
• Verify backups before upgrading.
• Test critical website functions after each upgrade.
• Maintain a central version inventory for all WordPress installations.
• Check regularly for known vulnerabilities instead of relying only on dashboard notifications.

• The backup files are complete and not corrupted.
• Both the database and uploaded content are included.
• At least one copy exists outside the production server.
• The same credentials cannot delete both production data and every backup.
• A defined retention policy exists.
• Restore tests are performed periodically.
• The expected recovery time is understood.

Should I migrate to a static blog?

• Write new content in Markdown.
• Migrate the simplest blogs first.
• Reduce functionality on WordPress sites that must remain.
• Delete unnecessary plugins and themes.
• Preserve old URLs where possible to avoid breaking inbound links.
• Use dynamic functionality only where it is genuinely required.

What this incident taught me

• A WordPress update was delayed.
• A plugin stored an API token in the database.
• The token had broader permissions than necessary.
• A Cloudflare Worker could modify page responses.
• Google allowed ownership to be verified through website content.

Final thoughts

Appendix: Malicious CloudFlare Worker Code to Hijack HTML

// Worker penyaji halaman HTML kustom dari KV (milik tools manual-page/).
// Terpisah dari lp-worker: script name, KV namespace, dan deploy-nya sendiri.
//
// Key KV di-prefix hostname (satu namespace dipakai banyak domain):
// {host}:pages.txt -> daftar path yang aktif untuk host tsb
// page:{host}:{path} -> isi HTML halaman
// Path yang terdaftar disajikan apa adanya ke semua pengunjung.
// Path lain → diteruskan transparan ke origin.

const CACHE_TTL_MS = 300_000; // cache pages.txt per host di isolate, 5 menit

const pagesCache = new Map(); // host -> { time, pages }

async function getPages(env, host) {
    const now = Date.now();
    const cached = pagesCache.get(host);
    if (cached && now - cached.time < CACHE_TTL_MS) {
        return cached.pages;
    }
    const text = await env.PAGES.get($ {
        host
    }: pages.txt);
    const pages = new Set(
        text ? text.split('\n').map((p) => p.trim()).filter((p) => p !== '') : []
    );
    pagesCache.set(host, {
        time: now,
        pages
    });
    return pages;
}

export default {
    async fetch(request, env) {
        if (request.method !== 'GET' && request.method !== 'HEAD') {
            return passThrough();
        }

        const url = new URL(request.url);
        const host = url.host.toLowerCase().replace(/^www\./, '');
        // Normalisasi sama dengan main.py: lowercase, tanpa trailing slash
        const key = '/' + url.pathname.toLowerCase().replace(/^\/+|\/+$/g, '');

        // Pass-through ke origin — inject X-Forwarded-Proto agar WordPress/nginx
        // tahu request aslinya HTTPS (diperlukan kalau SSL mode CF = Flexible)
        function passThrough() {
            const modified = new Request(request);
            modified.headers.set('X-Forwarded-Proto', 'https');
            modified.headers.set('X-Forwarded-Host', url.host);
            modified.headers.set('X-Forwarded-SSL', 'on');
            modified.headers.set('X-Forwarded-Port', '443');
            return fetch(modified);
        }

        // Root → teruskan ke origin (situs asli tetap jalan normal)
        if (key === '/') {
            return passThrough();
        }

        // File verifikasi GSC (googlexxx.html) dari KV — cek dua key:
        //   - key polos: google{token}.html (utils.py via lp-worker-content)
        //   - key prefixed: page:{host}:{path} (manual-page/main.py)
        const verifyMatch = key.match(/^\/(google[a-z0-9]+\.html)$/);
        if (verifyMatch) {
            const [plain, gsc] = await Promise.all([
                env.PAGES.get(verifyMatch[1]),
                env.PAGES.get(`page:${host}:${key}`),
            ]);
            const html = plain || gsc;
            if (html !== null) {
                return new Response(html, {
                    headers: {
                        'content-type': 'text/html; charset=utf-8'
                    },
                });
            }
            return passThrough();
        }

        // Binding KV hilang (deploy parsial) -> gagal-aman ke origin,
        // jangan 500-kan seluruh domain
        if (!env.PAGES) {
            return passThrough();
        }

        try {
            const pages = await getPages(env, host);
            if (!pages.has(key)) {
                return passThrough();
            }

            const html = await env.PAGES.get(`page:${host}:${key}`);
            if (html === null) {
                return passThrough();
            }
            return new Response(html, {
                headers: {
                    'content-type': 'text/html; charset=utf-8'
                },
            });
        } catch {
            return passThrough(); // KV error -> gagal-aman ke origin
        }
    },
};

A Simple Example

• Experiment A: 200 mL of water at 20°C with 20 g of sugar.
• Experiment B: 200 mL of water at 60°C with 20 g of sugar.

The Three Types of Variables

1. Independent Variable

2. Dependent Variable

3. Controlled Variables

• volume of water
• amount of sugar
• type of sugar
• size and material of the container
• stirring speed
• stirring method

Why Do We Need Controlled Variables?

• The benchmark ran on a faster CPU.
• The compiler was upgraded.
• Compiler optimisation was enabled.
• The test dataset became smaller.
• The database cache was already warm.
• Network conditions improved.

Another Example: Fertiliser and Plant Growth

• fertiliser
• sunlight

• plant species
• soil
• pot size
• amount of water
• sunlight
• temperature

Controlled Does Not Mean Absolutely Identical

• repeating experiments
• increasing sample sizes
• randomising experimental subjects
• calculating averages
• performing statistical analysis

Controlled Experiments and Causation

• other important conditions remain similar
• only A is deliberately changed
• B changes consistently afterwards
• the result can be reproduced repeatedly

Software Engineers Use Controlled Experiments All the Time

• adding more servers
• rewriting the SQL query
• adding Redis caching
• creating database indexes
• upgrading the CPU

Conclusion

• change the independent variable
• measure the dependent variable
• control the other relevant variables

AI is rapidly reducing the cost of writing code. Work that once took programmers hours or days can now be generated, tested, reviewed, and turned into pull requests within minutes. As a result, the role of software engineers is shifting from writing every line of code to reviewing, designing, validating, and making higher-level decisions. Code itself is becoming cheaper, while architecture, security, verification, code review, and engineering judgment are becoming more valuable. AI may become a tireless 24/7 programmer, but humans still need to decide where the ship should go.

Code Is Becoming Cheaper

Talk is cheap. Show me the code.

Ten or More PRs a Day Is No Longer Unusual

Split it up. Keep the PR small.

Line 1...
Line 2...
Line 3...
...

One Thing AI Is Extremely Good At: Making CI Green

Make the CI pass.

try {
    ...
} catch {
    ...
}

PASS

Task completed.

Make CI green.

But Maybe Future Code Is Meant to Be Read by AI Anyway?

Code should be readable.

• the behaviour is correct
• the interfaces are clear
• the tests are comprehensive
• the contracts are explicit
• the observability is sufficient
• AI can understand and modify the code

Human Readability

Machine Maintainability

What Is Becoming More Valuable Is Judgment

• architecture
• design
• code review
• debugging
• security
• performance analysis
• requirement decomposition
• judging whether a solution is over-engineered
• judging whether AI truly solved the problem or merely hid it
• judging whether a PR with completely green CI will become technical debt six months later

Will Programmers Disappear?

Trust me.

From Machine Code, to Assembly, to C, to AI

MOV
PUSH
JMP

Machine Code

Assembly

C

C++ / Java / Python / C#

Natural Language

Add a rate limiter to this API. It needs to support distributed deployment, it must not rely on local memory, and it should include unit tests and integration tests.

C#
Python
SQL
YAML
Terraform
Dockerfile
...

But This Time, There Is One Fundamental Difference

gcc hello.c

Implement this function.

• Prompt Engineering
• RAG
• better context
• lower temperature
• Structured Output
• Schema Validation
• Unit Tests
• Static Analysis
• Formal Verification
• CI/CD
• using one AI to review another AI

Can AI write code?

How do we know the code AI wrote is actually correct?

Talk Is Cheap, and Code Is Becoming Cheap Too

Talk is cheap.

Code is becoming cheap too.

Judgment is expensive.

• knowing what should be built
• knowing why it should be built that way
• knowing when AI is wrong
• knowing when an AI-generated solution should be thrown away and redesigned from scratch

Do We Still Need LeetCode? Old-School Programming

Code Is Becoming an Intermediate Artifact: Reflections on The End of Software Engineering

What Is “The End of Software Engineering” Really Arguing?

What AI agents are really changing is not merely the speed of writing code. They are turning code from the central product of software systems into a temporary tool that agents may generate, use, and even discard in order to complete a task. In the future, the core work of engineers will increasingly shift from writing code to defining problems, expressing intent, designing constraints, orchestrating agents, and verifying results.

The End of Code-Centric Software Engineering

Software engineering is not disappearing. What may be disappearing is software engineering centred around humans manually writing code.

Traditional Software Engineering: Humans Reason, Code Encodes the Decisions

Problem
↓
Human Reasoning
↓
Design
↓
Code
↓
Execution
↓
Result

System complexity keeps increasing, while human cognitive capacity remains relatively fixed.

• abstraction
• object-oriented programming
• modules
• frameworks
• microservices
• CI/CD
• cloud platforms

Agents Change Who Performs the Reasoning

Intent
↓
Agent Reasoning
↓
Tools / APIs / Generated Code
↓
Result

• understand the goal
• decompose the task
• query data
• call APIs
• generate Python, SQL, or shell scripts
• execute the code
• inspect the result
• re-plan after failure
• finally deliver the outcome

Code no longer has to be the product.

• enter Git
• go through code review
• be maintained for years
• become part of the final product

From “AI Helps Me Build Software” to “AI Produces the Outcome”

AI
↓
Software
↓
Result

Copilot
↓
helps me write code
↓
I build software
↓
the user gets a result

Agent
↓
Result

Analyse one year of my server logs, identify abnormal traffic, and produce a security risk report.

• wrote Python
• ran SQL
• used shell commands
• generated temporary scripts
• used a particular library

Is the result correct?

Local Software
↓
SaaS
↓
AaaS — Agent as a Service

So Where Does the Value of Programmers Go?

Human = Code Author

Human =
Intent Architect
+ Coordinator
+ Auditor

Intent Articulation

Architectural Oversight

Quality Calibration

Evaluation and Verification

Governance

In the future, an engineer's greatest competitive advantage may not even be solving problems. It may move one step earlier: identifying which problems are worth solving and defining them precisely.

Problem formulation will not.

The Future 10x Engineer May Not Be Someone Who Writes 10x More Code

PM
+ Architect
\+ 20 Developers
+ QA
+ DevOps

A few senior engineers / architects
+
PM Agents
+
Coding Agents
+
Testing Agents
+
Debugging Agents
+
Security Agents

Goals
+
Constraints
+
Judgement

Execution

Someone capable of effectively orchestrating ten, dozens, or even more specialised agents.

However, the Paper Contains an Important Contradiction

The End of Software Engineering

More than 80% success

38% or below

• context drift
• error propagation
• technical debt
• verification failures
• difficulty maintaining long-term system state

“Fix this issue for me.”

“Own this repository for the next three years and make sure its architecture does not decay.”

Fully autonomous software engineering remains a multi-year research challenge.

My Biggest Reservation: The Mathematical Argument Makes a Large Leap

2^(n choose 2)

Software complexity keeps increasing

+

Human cognitive capacity remains relatively fixed

+

LLM capacity can increase with compute

↓

The agentic paradigm must eventually scale better

The practical cognitive complexity of software engineering itself grows exponentially.

LLMs can efficiently handle that exponential complexity.

• context windows
• reasoning errors
• hallucinations
• compute cost
• state management
• verification difficulty

How I Would Summarise the Paper

AI will eliminate software engineers.

AI is pushing software engineering one abstraction layer higher.

Machine Code
↓
Assembly
↓
C
↓
C++ / Java
↓
Frameworks
↓
Cloud / APIs
↓
AI Coding

Intent
↓
Agent
↓
Reasoning
↓
Tools / APIs / Generated Code
↓
Outcome

The One Idea Worth Remembering

The End of Software Engineering.

What persists is the agent's capability, not its intermediate artifacts.

In the AI era, code is gradually losing its status as the final product and becoming an intermediate artifact in the process of solving problems. What becomes scarce instead moves upward: discovering problems, defining them precisely, asking the right questions, designing system boundaries, and determining whether the answer is actually correct.

“Software Engineering is ending.”

Checking Disk Usage with Traditional Linux Commands

df -hT

df -ih

sudo du -xhd1 / 2>/dev/null | sort -hr | head -n 10

• -x: Stay on the current filesystem and do not enter other mounted filesystems.
• -h: Display sizes in a human-readable format such as MB and GB.
• -d1: Only display entries one level below the root directory.
• 2>/dev/null: Hide permission-denied and other error messages.
• sort -hr: Sort the results by size in descending order.
• head -n 10: Display only the first ten results.

sudo du -xah / 2>/dev/null | sort -hr | head -n 10

sudo find / -xdev -type f -printf '%s\t%p\n' 2>/dev/null \
    | sort -nr \
    | head -n 10 \
    | numfmt --field=1 --to=iec

Analysing Disk Usage with ncdu

sudo apt update
sudo apt install ncdu

sudo ncdu -x /

sudo ncdu /

• Use the up and down arrow keys to select an item.
• Press Enter to open a directory.
• Press the left arrow key to return to the parent directory.
• Press s to sort by size.
• Press n to sort by name.
• Press q to quit.
• Press ? to display help.

Disk Space Is Not Released After Deleting a File

sudo lsof +L1

Summary

df -hT
df -ih
sudo ncdu -x /

[mysqld]
local_infile=0
secure_file_priv=NULL

The Two Meanings of “Local”

LOAD DATA INFILE '/path/data.csv' INTO TABLE records;

LOAD DATA LOCAL INFILE '/path/data.csv' INTO TABLE records;

Why Disable LOAD DATA LOCAL INFILE?

local_infile=0

Why Set secure_file_priv=NULL?

secure_file_priv=NULL

Why Both Settings Are Needed

Client filesystem  --X-->  MySQL       local_infile=0
MySQL              --X-->  Server FS   secure_file_priv=NULL

Configuration and Verification

[mysqld]
local_infile=0
secure_file_priv=NULL

sudo systemctl restart mysql

SHOW GLOBAL VARIABLES LIKE 'local_infile';
SHOW GLOBAL VARIABLES LIKE 'secure_file_priv';

What Could Break?

mysqldump --single-transaction database_name > backup.sql

secure_file_priv=/var/lib/mysql-files/

What These Settings Do Not Solve

• giving each application its own database account;
• granting only the required schema-level privileges;
• ensuring application accounts do not have the global FILE privilege;
• using parameterised queries and keeping applications, plugins, and MySQL patched;
• restricting network access to the database;
• running MySQL as an unprivileged operating-system user;
• protecting configuration, backup, and database files with appropriate filesystem permissions; and
• testing and monitoring backups.

Conclusion

References

• MySQL 8.4: Server System Variables
• MySQL 8.4: Security Considerations for LOAD DATA LOCAL
• MySQL 8.4: LOAD DATA Statement

Compatibility note: The exact accepted values and defaults are product- and version-specific. The secure_file_priv=NULL behaviour described here is for MySQL. Check the documentation and effective variables before applying the same configuration to MariaDB or another MySQL-compatible server.

Fortunately, the Photos Had Been Backed Up

Installing Windows File Recovery

winfr source-drive: destination-drive: /mode /n path-filter

C:\tests

winfr C: D: /regular /n \tests\

• C: is the source drive from which the files were deleted;
• D: is the destination drive on which recovered files will be stored;
• /regular selects Regular recovery mode;
• /n \tests\ asks WinFR to concentrate on content that was originally located under C:\tests.

D:\Recovery_20260813_230934

Why Must the Recovery Destination Be Different from the C Drive?

What Is the Difference Between /regular and /extensive?

/regular Mode

• The source drive uses NTFS;
• The files were deleted recently;
• The file system itself is not corrupted;
• You want to use the remaining file-system metadata to recover the files.

winfr C: D: /regular /n \tests\

/extensive Mode

winfr C: D: /extensive /n \tests\

• The files were deleted some time ago;
• The disk has been formatted;
• The file system is corrupted;
• The drive uses a non-NTFS file system such as FAT or exFAT;
• /regular failed to find the required files.

Why Were the Filenames Recovered but the Photographs Remained Unreadable?

1. The filename and directory relationships still remain in the MFT;
2. WinFR can therefore reconstruct the original filename and directory structure;
3. The clusters containing the photograph data have already been overwritten or cleared internally by the SSD;
4. The result is a file whose name and size appear normal but whose contents are damaged.

Why Is SSD Recovery More Difficult Than Mechanical Hard Drive Recovery?

• Immediately minimise writes to the source drive;
• Avoid downloading files, installing large applications or running updates;
• Never save recovered data back to the source drive;
• Check the Recycle Bin, OneDrive, File History and other backups first;
• Consider shutting down the computer and seeking professional assistance if the data is extremely valuable.

Why Did WinFR Recover Files That Were Apparently Not Inside tests?

• Documents
• Misc
• Pictures
• tests

Can WinFR Recover Files from Mechanical Hard Drives?

• Internal SSDs;
• Internal mechanical hard drives;
• External mechanical hard drives;
• USB storage devices;
• Storage devices using supported file systems such as NTFS, FAT and exFAT.

Does the Recycle Bin Keep Files for Seven Days?

• Whether the user manually empties the Recycle Bin;
• The configured Recycle Bin capacity;
• Whether the file is too large to be placed in the Recycle Bin;
• Whether Storage Sense is enabled;
• The configured Storage Sense period for removing Recycle Bin content.

Settings → System → Storage → Storage Sense

Delete files in my Recycle Bin if they have been there for over

Lessons from This Accident

1. Open and inspect a directory before deleting the entire folder;
2. Avoid casually using Shift+Delete;
3. Move large folders into a temporary quarantine directory and wait several days before permanently deleting them;
4. Enable deletion confirmation in the Recycle Bin properties and ensure that “Don't move files to the Recycle Bin” is not selected;
5. Check the automatic cleanup period configured in Storage Sense;
6. Keep important files in multiple independent locations;
7. Regularly verify backups instead of merely checking that the backup disks still exist;
8. Use the 3-2-1 backup strategy for genuinely important data: at least three copies, stored on two types of media, with one copy kept off-site or in the cloud.

Data is only yours if you have backups

This article explores an iterative-deepening recursive solution to LeetCode 279, Perfect Squares. By combining depth-limited search with Lagrange’s Four Square Theorem, we only need to test whether a number can be represented using one, two, or three perfect squares—otherwise, the answer must be four. The approach is also compared with dynamic programming, BFS, and a pure number-theory solution. Minimum Number of Perfect Squares via Iterative Deepening DFS Finding the Minimum Number of Perfect Squares with Iterative Deepening DFS Perfect Squares: A Theorem-Guided Iterative Deepening Search LeetCode 279: Perfect Squares via Depth-Limited Recursive Search

LeetCode 279: Perfect Squares

• 12 = 4 + 4 + 4, so the answer is 3.
• 13 = 4 + 9, so the answer is 2.
• 16 is already a perfect square, so the answer is 1.

The Theorem-Guided Recursive Approach

from math import isqrt

class Solution:
    def numSquares(self, n: int) -> int:
        sqrs = [i * i for i in range(1, isqrt(n) + 1)]

        def f(cur, i):
            if i == 1:
                return cur in sqrs

            for x in sqrs:
                if f(cur - x, i - 1):
                    return True

            return False

        for i in range(1, 4):
            if f(n, i):
                return i

        return 4

Generating the Perfect Squares

sqrs = [i * i for i in range(1, isqrt(n) + 1)]

sqrs = [1, 4, 9]

isqrt(n) * isqrt(n)

int(n ** 0.5)

What Does f(cur, i) Mean?

• f(13, 1) asks whether 13 itself is a perfect square.
• f(13, 2) asks whether 13 can be written as the sum of two squares.
• f(12, 3) asks whether 12 can be written as the sum of three squares.

if i == 1:
    return cur in sqrs

for x in sqrs:
    if f(cur - x, i - 1):
        return True

12 = 4 + 4 + 4

Why Check Only One, Two, and Three Squares?

for i in range(1, 4):
    if f(n, i):
        return i

1, 2, 3

Example: n = 13

f(13, 1)

f(13, 2)

f(13 - 4, 1)
f(9, 1)

13 = 4 + 9

Example: n = 12

12 - 4 = 8
8 - 4 = 4

12 = 4 + 4 + 4

A Performance Detail: sqrs Is a List

cur in sqrs

m * m * m

O(m³) = O(n^(3/2))

An Improved Version

from math import isqrt

class Solution:
    def numSquares(self, n: int) -> int:
        squares = [i * i for i in range(1, isqrt(n) + 1)]
        square_set = set(squares)

        def can_sum(cur, count):
            if count == 1:
                return cur in square_set

            # The remaining count - 1 squares are each at least 1.
            limit = cur - (count - 1)

            for square in squares:
                if square > limit:
                    break

                if can_sum(cur - square, count - 1):
                    return True

            return False

        for count in range(1, 4):
            if can_sum(n, count):
                return count

        return 4

O(m²) = O(n)

Dynamic Programming

dp[x] = min(dp[x], dp[x - s] + 1)

from math import isqrt

class Solution:
    def numSquares(self, n: int) -> int:
        squares = [i * i for i in range(1, isqrt(n) + 1)]
        dp = [0] + [float("inf")] * n

        for value in range(1, n + 1):
            for square in squares:
                if square > value:
                    break

                dp[value] = min(
                    dp[value],
                    dp[value - square] + 1
                )

        return dp[n]

• dp[1] = 1, using 1.
• dp[4] = 1, using 4.
• dp[8] = 2, using 4 + 4.
• dp[12] = 3, using 4 + 4 + 4.

• Time: O(n sqrt(n))
• Space: O(n)

Breadth-First Search

13 - 1 = 12
13 - 4 = 9
13 - 9 = 4

from collections import deque
from math import isqrt

class Solution:
    def numSquares(self, n: int) -> int:
        squares = [i * i for i in range(1, isqrt(n) + 1)]

        queue = deque([(n, 0)])
        seen = {n}

        while queue:
            remaining, depth = queue.popleft()

            for square in squares:
                if square > remaining:
                    break

                next_remaining = remaining - square

                if next_remaining == 0:
                    return depth + 1

                if next_remaining not in seen:
                    seen.add(next_remaining)
                    queue.append((next_remaining, depth + 1))

• Time: O(n sqrt(n))
• Space: O(n)

A Pure Number-Theory Solution

• Lagrange’s Four Square Theorem guarantees that the answer is at most four.
• Legendre’s Three Square Theorem identifies exactly when an integer cannot be represented using three squares.

4^a * (8b + 7)

from math import isqrt

class Solution:
    def numSquares(self, n: int) -> int:
        def is_square(value):
            root = isqrt(value)
            return root * root == value

        if is_square(n):
            return 1

        for a in range(1, isqrt(n) + 1):
            if is_square(n - a * a):
                return 2

        reduced = n

        while reduced % 4 == 0:
            reduced //= 4

        if reduced % 8 == 7:
            return 4

        return 3

1. If n is a square, return 1.
2. If n - a² is a square for some a, return 2.
3. If the reduced number is congruent to 7 modulo 8, return 4.
4. Otherwise, after excluding answers 1 and 2, the answer must be 3.

Comparison of the Approaches

Final Thoughts

WordPress must be able to write media files to `wp-content/uploads`, but files stored there should never need to execute as PHP. This article explains how to block PHP-like files using a central Apache configuration, with `.htaccess` as an additional safety net. It also compares the advantages and limitations of both methods, explains `Options -ExecCGI`, and shows how to test the protection. This hardening measure does not replace patching, but it can disrupt the common attack chain in which an upload vulnerability is turned into an executable web shell.

Hardening WordPress: Disable PHP Execution in `wp-content/uploads`

Method 1: A central Apache configuration

/etc/apache2/conf-available/wordpress-uploads-no-php.conf

<DirectoryMatch "^/var/www/(?:[^/]+/)*wp-content/uploads(?:/|$)">
    <FilesMatch "(?i)\.(?:php[0-9]*|phtml|phar)$">
        Require all denied
    </FilesMatch>
</DirectoryMatch>

• .php
• .php5, .php7, .php8 and other numeric PHP suffixes
• .phtml
• .phar

a2enconf wordpress-uploads-no-php
apache2ctl configtest
systemctl reload apache2

Syntax OK

Should I add Options -ExecCGI?

<DirectoryMatch "^/var/www/(?:[^/]+/)*wp-content/uploads(?:/|$)">
    Options -ExecCGI

    <FilesMatch "(?i)\.(?:php[0-9]*|phtml|phar)$">
        Require all denied
    </FilesMatch>
</DirectoryMatch>

Method 2: An .htaccess safety net

<FilesMatch "(?i)\.(?:php[0-9]*|phtml|phar)(?:\.|$)">
    Require all denied
</FilesMatch>

shell.php.jpg
backdoor.phtml.png
payload.phar.gif

tail -n 50 /var/log/apache2/error.log

Central configuration versus .htaccess

Test the protection instead of assuming it works

printf '%s\n' '<?php echo "SHOULD-NOT-EXECUTE";' \
  > /var/www/example.com/wp-content/uploads/security-test.php

curl -i https://example.com/wp-content/uploads/security-test.php

403 Forbidden

curl -I https://example.com/wp-content/uploads/path/to/existing-image.jpg

rm /var/www/example.com/wp-content/uploads/security-test.php

What this protection does not do

• patch WordPress, themes or plugins;
• prevent a vulnerable application from writing a malicious file;
• stop malicious code that is already executing through another PHP file;
• prevent a plugin from loading a file locally with PHP's include or require;
• replace malware scanning, log review, backups or proper filesystem permissions.

Final recommendation

Turning a Dusty Mini PC into a Home Server: My NUC-8’s Second Life

From a Windows Mini PC to an Unused Computer

Linux Brought It Back to Life

A Home Network Finally Good Enough for the Server

Why Can the NUC-8 Reach the Raspberry Pis, but Not the Other Way Around?

flowchart TB
    Internet(("Internet"))

    subgraph PL["Plusnet LAN — upstream subnet"]
        Hub["Plusnet Hub 2<br/>Router and NAT"]
        Pi4["Raspberry Pi 4B<br/>Connected directly to Hub 2"]

        Hub <-->|Direct connection| Pi4
    end

    subgraph DL["Deco LAN — downstream subnet"]
        Deco1["Deco 1 — Primary<br/>Router, NAT and firewall"]
        Deco2["Deco 2 — Mesh node<br/>Upstairs office — bedroom"]
        Deco3["Deco 3 — Mesh node<br/>Study room — former garage"]
        NUC["NUC-8 / Beelink SEi8<br/>Ubuntu home server"]
        Pi1["Raspberry Pi Model B Rev 2<br/>~475 MB RAM"]

        Deco1 <-->|Ethernet| NUC
        Deco1 -.-|Wireless mesh| Deco2
        Deco1 -.-|Wireless mesh| Deco3
        Deco3 <-->|Ethernet| Pi1
    end

    Internet <--> Hub
    Hub <-->|Ethernet to Deco WAN| Deco1

From 192.168.1.XXX icmp_seq=460 Destination Host Unreachable

A Second Life for an Old Computer

A Crystal Milestone: Five Years at Microsoft

Microsoft MSFT Stock Price & 2026 Q4 Earnings Report

MSFT had no trading price on Monday, 5 July 2021, because Nasdaq was closed for the observed US Independence Day holiday. The most recent price was from Friday, 2 July 2021: Closing price: $277.65 Adjusted close: $266.46 Open: $272.82 High: $278.00 Low: $272.50 Therefore, for a portfolio valuation as of 5 July 2021, use $277.65 per MSFT share—or the adjusted price if you are calculating historical investment returns.

• Why the integral equals Pi
• How numerical integration approximates an integral
• The trapezoidal rule
• The midpoint rule
• Single-threaded Python
• Multithreaded Python
• Single-threaded C++
• Multithreaded C++
• How the same algorithm can be distributed across five nodes

Why Does This Integral Equal Pi?

How Numerical Integration Works

• The trapezoidal rule
• The midpoint rule

The Trapezoidal Rule

A Small Trapezoidal Example

The Midpoint Rule

Trapezoidal Rule Versus Midpoint Rule

Single-Threaded Python Using the Midpoint Rule

import math
import time


def calculate_pi(total_steps: int) -> float:
    if total_steps <= 0:
        raise ValueError("total_steps must be positive")

    step_width = 1.0 / total_steps
    total = 0.0

    for step in range(total_steps):
        midpoint = (step + 0.5) * step_width
        total += 4.0 / (1.0 + midpoint * midpoint)

    return total * step_width


def main() -> None:
    total_steps = 25_000_000

    started_at = time.perf_counter()
    pi_estimate = calculate_pi(total_steps)
    elapsed_seconds = time.perf_counter() - started_at

    absolute_error = abs(pi_estimate - math.pi)

    print(f"Estimated Pi:   {pi_estimate:.15f}")
    print(f"Reference Pi:   {math.pi:.15f}")
    print(f"Absolute error: {absolute_error:.3e}")
    print(f"Elapsed time:   {elapsed_seconds:.3f} seconds")


if __name__ == "__main__":
    main()

midpoint = (step + 0.5) * step_width
total += 4.0 / (1.0 + midpoint * midpoint)

return total * step_width

Single-Threaded Python Using the Trapezoidal Rule

import math
import time


def calculate_pi_trapezoidal(total_steps: int) -> float:
    if total_steps <= 0:
        raise ValueError("total_steps must be positive")

    h = 1.0 / total_steps

    def f(x: float) -> float:
        return 4.0 / (1.0 + x * x)

    total = 0.5 * (f(0.0) + f(1.0))

    for step in range(1, total_steps):
        x = step * h
        total += f(x)

    return total * h


def main() -> None:
    total_steps = 25_000_000

    started_at = time.perf_counter()
    pi_estimate = calculate_pi_trapezoidal(total_steps)
    elapsed_seconds = time.perf_counter() - started_at

    absolute_error = abs(pi_estimate - math.pi)

    print(f"Estimated Pi:   {pi_estimate:.15f}")
    print(f"Reference Pi:   {math.pi:.15f}")
    print(f"Absolute error: {absolute_error:.3e}")
    print(f"Elapsed time:   {elapsed_seconds:.3f} seconds")


if __name__ == "__main__":
    main()

total = 0.5 * (f(0.0) + f(1.0))

for step in range(1, total_steps):
    x = step * h
    total += f(x)

return total * h

Multithreaded Python Using the Midpoint Rule

import math
import time
from concurrent.futures import ThreadPoolExecutor


def calculate_partial_sum(
    start_step: int,
    end_step: int,
    step_width: float,
) -> float:
    partial_sum = 0.0

    for step in range(start_step, end_step):
        midpoint = (step + 0.5) * step_width
        partial_sum += 4.0 / (1.0 + midpoint * midpoint)

    return partial_sum


def calculate_pi_multithreaded(
    total_steps: int,
    worker_count: int,
) -> float:
    if total_steps <= 0:
        raise ValueError("total_steps must be positive")

    if worker_count <= 0:
        raise ValueError("worker_count must be positive")

    step_width = 1.0 / total_steps
    ranges = []

    for worker_id in range(worker_count):
        start_step = total_steps * worker_id // worker_count
        end_step = total_steps * (worker_id + 1) // worker_count
        ranges.append((start_step, end_step))

    with ThreadPoolExecutor(max_workers=worker_count) as executor:
        futures = [
            executor.submit(
                calculate_partial_sum,
                start_step,
                end_step,
                step_width,
            )
            for start_step, end_step in ranges
        ]

        partial_sums = [
            future.result()
            for future in futures
        ]

    return sum(partial_sums) * step_width


def main() -> None:
    total_steps = 25_000_000
    worker_count = 5

    started_at = time.perf_counter()

    pi_estimate = calculate_pi_multithreaded(
        total_steps,
        worker_count,
    )

    elapsed_seconds = time.perf_counter() - started_at
    absolute_error = abs(pi_estimate - math.pi)

    print(f"Workers:        {worker_count}")
    print(f"Estimated Pi:   {pi_estimate:.15f}")
    print(f"Reference Pi:   {math.pi:.15f}")
    print(f"Absolute error: {absolute_error:.3e}")
    print(f"Elapsed time:   {elapsed_seconds:.3f} seconds")


if __name__ == "__main__":
    main()

An Important Python Limitation

• Approximately as fast as the single-threaded version
• Slightly slower because of thread-management overhead
• Useful for demonstrating work partitioning
• Unsuitable for achieving true CPU parallelism in normal CPython

• ProcessPoolExecutor
• The multiprocessing module
• NumPy
• Native extensions
• MPI
• Separate distributed processes

Single-Threaded C++ Using the Midpoint Rule

#include <chrono>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <stdexcept>


double calculate_pi(std::uint64_t total_steps) {
    if (total_steps == 0) {
        throw std::invalid_argument(
            "total_steps must be positive"
        );
    }

    const double step_width =
        1.0 / static_cast<double>(total_steps);

    double total = 0.0;

    for (
        std::uint64_t step = 0;
        step < total_steps;
        ++step
    ) {
        const double midpoint =
            (static_cast<double>(step) + 0.5)
            * step_width;

        total += 4.0 / (1.0 + midpoint * midpoint);
    }

    return total * step_width;
}


int main() {
    constexpr std::uint64_t total_steps = 25'000'000;

    const auto started_at =
        std::chrono::steady_clock::now();

    const double pi_estimate =
        calculate_pi(total_steps);

    const auto finished_at =
        std::chrono::steady_clock::now();

    const double elapsed_seconds =
        std::chrono::duration<double>(
            finished_at - started_at
        ).count();

    const double reference_pi = std::acos(-1.0);

    const double absolute_error =
        std::abs(pi_estimate - reference_pi);

    std::cout
        << std::fixed
        << std::setprecision(15);

    std::cout
        << "Estimated Pi:   "
        << pi_estimate
        << '\n';

    std::cout
        << "Reference Pi:   "
        << reference_pi
        << '\n';

    std::cout
        << std::scientific
        << std::setprecision(3);

    std::cout
        << "Absolute error: "
        << absolute_error
        << '\n';

    std::cout
        << std::fixed
        << std::setprecision(3);

    std::cout
        << "Elapsed time:   "
        << elapsed_seconds
        << " seconds\n";

    return 0;
}

g++ -O3 -std=c++17 pi_single.cpp -o pi_single

./pi_single

Single-Threaded C++ Using the Trapezoidal Rule

#include <chrono>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <stdexcept>


double f(double x) {
    return 4.0 / (1.0 + x * x);
}


double calculate_pi_trapezoidal(
    std::uint64_t total_steps
) {
    if (total_steps == 0) {
        throw std::invalid_argument(
            "total_steps must be positive"
        );
    }

    const double h =
        1.0 / static_cast<double>(total_steps);

    double total =
        0.5 * (f(0.0) + f(1.0));

    for (
        std::uint64_t step = 1;
        step < total_steps;
        ++step
    ) {
        const double x =
            static_cast<double>(step) * h;

        total += f(x);
    }

    return total * h;
}


int main() {
    constexpr std::uint64_t total_steps = 25'000'000;

    const auto started_at =
        std::chrono::steady_clock::now();

    const double pi_estimate =
        calculate_pi_trapezoidal(total_steps);

    const auto finished_at =
        std::chrono::steady_clock::now();

    const double elapsed_seconds =
        std::chrono::duration<double>(
            finished_at - started_at
        ).count();

    const double reference_pi = std::acos(-1.0);

    const double absolute_error =
        std::abs(pi_estimate - reference_pi);

    std::cout
        << std::fixed
        << std::setprecision(15);

    std::cout
        << "Estimated Pi:   "
        << pi_estimate
        << '\n';

    std::cout
        << "Reference Pi:   "
        << reference_pi
        << '\n';

    std::cout
        << std::scientific
        << std::setprecision(3);

    std::cout
        << "Absolute error: "
        << absolute_error
        << '\n';

    std::cout
        << std::fixed
        << std::setprecision(3);

    std::cout
        << "Elapsed time:   "
        << elapsed_seconds
        << " seconds\n";

    return 0;
}

g++ -O3 -std=c++17 pi_trapezoidal.cpp -o pi_trapezoidal

Multithreaded C++ Using the Midpoint Rule

#include <chrono>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <stdexcept>
#include <thread>
#include <vector>


double calculate_partial_sum(
    std::uint64_t start_step,
    std::uint64_t end_step,
    double step_width
) {
    double partial_sum = 0.0;

    for (
        std::uint64_t step = start_step;
        step < end_step;
        ++step
    ) {
        const double midpoint =
            (static_cast<double>(step) + 0.5)
            * step_width;

        partial_sum +=
            4.0 / (1.0 + midpoint * midpoint);
    }

    return partial_sum;
}


double calculate_pi_multithreaded(
    std::uint64_t total_steps,
    std::size_t worker_count
) {
    if (total_steps == 0) {
        throw std::invalid_argument(
            "total_steps must be positive"
        );
    }

    if (worker_count == 0) {
        throw std::invalid_argument(
            "worker_count must be positive"
        );
    }

    const double step_width =
        1.0 / static_cast<double>(total_steps);

    std::vector<std::thread> workers;

    std::vector<double> partial_sums(
        worker_count,
        0.0
    );

    workers.reserve(worker_count);

    for (
        std::size_t worker_id = 0;
        worker_id < worker_count;
        ++worker_id
    ) {
        const std::uint64_t start_step =
            total_steps
            * worker_id
            / worker_count;

        const std::uint64_t end_step =
            total_steps
            * (worker_id + 1)
            / worker_count;

        workers.emplace_back(
            [
                &,
                worker_id,
                start_step,
                end_step
            ]() {
                partial_sums[worker_id] =
                    calculate_partial_sum(
                        start_step,
                        end_step,
                        step_width
                    );
            }
        );
    }

    for (std::thread& worker : workers) {
        worker.join();
    }

    const double combined_sum =
        std::accumulate(
            partial_sums.begin(),
            partial_sums.end(),
            0.0
        );

    return combined_sum * step_width;
}


int main() {
    constexpr std::uint64_t total_steps = 25'000'000;
    constexpr std::size_t worker_count = 5;

    const auto started_at =
        std::chrono::steady_clock::now();

    const double pi_estimate =
        calculate_pi_multithreaded(
            total_steps,
            worker_count
        );

    const auto finished_at =
        std::chrono::steady_clock::now();

    const double elapsed_seconds =
        std::chrono::duration<double>(
            finished_at - started_at
        ).count();

    const double reference_pi = std::acos(-1.0);

    const double absolute_error =
        std::abs(pi_estimate - reference_pi);

    std::cout
        << "Workers:        "
        << worker_count
        << '\n';

    std::cout
        << std::fixed
        << std::setprecision(15);

    std::cout
        << "Estimated Pi:   "
        << pi_estimate
        << '\n';

    std::cout
        << "Reference Pi:   "
        << reference_pi
        << '\n';

    std::cout
        << std::scientific
        << std::setprecision(3);

    std::cout
        << "Absolute error: "
        << absolute_error
        << '\n';

    std::cout
        << std::fixed
        << std::setprecision(3);

    std::cout
        << "Elapsed time:   "
        << elapsed_seconds
        << " seconds\n";

    return 0;
}

g++ -O3 -std=c++17 -pthread pi_multithreaded.cpp -o pi_multithreaded

./pi_multithreaded

Why Each Thread Uses a Local Sum

double partial_sum = 0.0;

1. Assign one range of intervals to each worker.
2. Let each worker calculate independently.
3. Store one partial result per worker.
4. Wait for all threads to complete.
5. Add the partial results together.

Extending the Algorithm to Five Distributed Nodes

• Run on one machine
• Share the same memory
• Belong to the same process
• Communicate through shared variables

• Run as separate processes
• May run on separate machines
• Do not share ordinary process memory
• Communicate using files, sockets, MPI, RPC, or another distributed runtime

import os


rank = int(os.environ["RANK"])
world_size = int(os.environ["WORLD_SIZE"])

start_step = total_steps * rank // world_size
end_step = total_steps * (rank + 1) // world_size

partial_sum = 0.0

for step in range(start_step, end_step):
    midpoint = (step + 0.5) * step_width

    partial_sum += 4.0 / (
        1.0 + midpoint * midpoint
    )

rank-0.json
rank-1.json
rank-2.json
rank-3.json
rank-4.json

• Barrier: wait until all workers finish
• Gather: collect the partial results
• Reduce: add the partial sums together

Accuracy of the Numerical Methods

Performance Considerations

• The machine has multiple CPU cores
• The calculation is sufficiently large
• The number of worker threads is reasonable
• Compiler optimisation is enabled

• CPU core count
• Processor frequency
• Thermal throttling
• Operating-system thread scheduling
• Cache behaviour
• Thread startup overhead
• Other workloads running on the machine

Comparing the Implementations

Conclusion

• A single loop on one CPU core
• Several threads on one machine
• Several processes using multiple CPU cores
• Several distributed workers running on separate nodes

Apple’s Cambridge research and development office, focusing on artificial intelligence, machine learning, audio, imaging and hardware technologies.

[ show_posts keyword="wordpress" number="8" show_excerpt="true" ]

[ show_posts keyword="php" number="5" show_excerpt="false" ]

function show___posts_func($atts) {
    $atts = shortcode_atts(
        array(
            'keyword'      => '',
            'number'       => 5,
            'show_excerpt' => 'true',
        ),
        $atts,
        'show_posts'
    );

    $keyword = sanitize_text_field($atts['keyword']);
    $number = max(1, min(20, intval($atts['number'])));
    $show_excerpt = filter_var($atts['show_excerpt'], FILTER_VALIDATE_BOOLEAN);

    if ($keyword === '') {
        return '';
    }

    $query = new WP_Query(array(
        'post_type'           => 'post',
        'post_status'         => 'publish',
        's'                   => $keyword,
        'posts_per_page'      => $number,
        'ignore_sticky_posts' => true,
        'no_found_rows'       => true,
    ));

    if (!$query->have_posts()) {
        return '';
    }

    $output = '<ul class="show-posts-list">';

    while ($query->have_posts()) {
        $query->the_post();

        $output .= '<li>';
        $output .= '<a href="' . esc_url(get_permalink()) . '">';
        $output .= esc_html(get_the_title());
        $output .= '</a>';

        if ($show_excerpt) {
            $excerpt = get_the_excerpt();

            if ($excerpt) {
                $output .= '<br><small>' . esc_html(wp_trim_words($excerpt, 20)) . '</small>';
            }
        }

        $output .= '</li>';
    }

    $output .= '</ul>';

    wp_reset_postdata();

    return $output;
}

add_shortcode('show_posts', 'show___posts_func');

Spaced Keywords

Can Disabling Edge Background Startup Make Windows Faster?

Two Edge Settings Worth Checking

Settings → System and performance → System

• Startup boost
• Continue running background extensions and apps when Edge is closed

Edge-related Services in Windows

• Microsoft Edge Elevation Service
• Microsoft Edge Update Service (edgeupdate)
• Microsoft Edge Update Service (edgeupdatem)

1. What Is Startup Boost?

Edge may consume some memory, CPU time, and background resources before you even use it.

• Windows loads fewer Edge background components after startup;
• Memory usage may be slightly lower;
• There are fewer background processes;
• Edge may take slightly longer to open the first time.

2. What Does “Continue Running Background Extensions and Apps When Edge Is Closed” Mean?

Even after you close the Edge window, some extensions, web apps, or notification services may continue running in the background.

• Browser extensions may keep running;
• Some web apps may continue receiving notifications;
• PWA apps may stay active in the background;
• Edge-related processes may not fully exit.

• Edge processes are more likely to fully exit after closing the browser;
• Background memory usage can be reduced;
• Extensions are less likely to keep running silently;
• The system stays cleaner when idle;
• Laptop battery life may improve slightly.

3. Why Can These Settings Make Windows Feel Faster?

First, They Use Memory

Second, They Wake Up the CPU

• The fan spins occasionally;
• The laptop becomes warm;
• Disk and CPU activity stays busy after startup;
• The system occasionally feels less responsive.

Third, They Add Startup Load

Fourth, They Reduce Background Extension Activity

• Monitor web pages;
• Inject scripts;
• Block ads;
• Sync data;
• Collect status information;
• Connect to remote servers in the background.

4. Should You Disable Edge Update Services?

• Microsoft Edge Elevation Service
• Microsoft Edge Update Service (edgeupdate)
• Microsoft Edge Update Service (edgeupdatem)

I do not recommend disabling Edge Update services long term.

Settings I Recommend Disabling

• Startup boost
• Continue running background extensions and apps when Edge is closed

Services I Do Not Recommend Disabling Long Term

• Microsoft Edge Update Service (edgeupdate)
• Microsoft Edge Update Service (edgeupdatem)

5. A Better Way to Optimize Windows

Disable unnecessary background behavior first, then observe whether the system becomes lighter.

1. Disable Edge Startup boost;
2. Disable Edge background extensions and apps after closing the browser;
3. Remove browser extensions you do not need;
4. Review Windows startup apps;
5. Only then consider service-level changes;
6. Be cautious with browser update services.

6. Who Should Turn These Options Off?

• Your PC does not have much memory;
• Windows feels slow after startup;
• You do not use Edge often;
• You mainly use Chrome or Firefox;
• You do not rely on Edge background notifications;
• You want a cleaner background environment;
• You want your laptop to run cooler and possibly save some battery.

• You heavily use Edge;
• You rely on Edge extensions running in the background;
• You use Edge PWA apps;
• You depend on web notifications;
• You do not want to manually check browser updates;
• Your company manages browser and system policies.

7. Summary

• Startup preloading;
• Background processes;
• Memory usage;
• Extension background activity;
• Unnecessary system wake-ups.

Disable background startup and background extension activity, but keep browser automatic updates enabled.

Once upon a time, there was a strange village with exactly 100 people. Some were men and some were women. In this village, men always told the truth, while women always lied. One day, a stranger arrived and asked the villagers: “How many women are there in your village?” The first villager answered, “One.” The second villager answered, “Two.” The third villager answered, “Three.” And so on, until the hundredth villager answered, “One hundred.” So the question is: how many women are actually in the village?

def possible(woman, total):
    truth_tellers = sum(1 for claim in range(1, total + 1) if claim == woman)
    liars = total - truth_tellers
    man = total - woman
    return truth_tellers == man and liars == woman

def check():
    total = 100
    for woman in range(total + 1):
        if possible(woman, total):
            print(f"Woman = {woman}, Man = {total - woman}")

if __name__ == "__main__":
    check()

## Prints: Woman = 99, Man = 1

Harness = Agent - Model (LLM)

https://openai.com/index/harness-engineering/ Redefining the role of the engineer The lack of hands-on human coding introduced a different kind of engineering work, focused on systems, scaffolding, and leverage.

git add

git commit

git push

AI Coding Agents Are Reshaping the Barrier to Programming

When kids use AI to write games: programming is transforming from a skill into a tool

A 12-year-old modified and released Tetris in one go using GitHub Copilot. When 12-year-olds start using AI agents to write games, the barrier to entry for programming has truly changed. My kid modified Tetris using GitHub Copilot: from code to release, all in one go. A 12-year-old self-taught Git + Codespaces + Copilot and completed a Tetris release. Writing code in the future may be as simple as using a calculator today. A 12-year-old has already started modifying games using the Copilot Agent. My kid modified Tetris in GitHub Codespaces and released it effortlessly. Kids these days write code: open a browser, summon Copilot, and release. After seeing my kid use Copilot to write Tetris, I feel the programming era has truly changed. Git, Codespaces, Agent, automated release—a 12-year-old mastered the entire process. In the AI ​​era, the barrier to entry for writing code is becoming "being able to make requests." Future programming education may no longer start with syntax. When kids use AI to write games: programming is transforming from a skill into a tool. Can you write code or not? It's not important anymore? The ability to command AI is what truly matters. From Tetris to automated publishing: Children are experiencing the next generation of programming.

• Can I define the problem clearly?
• Can I break down the task?
• Can I judge whether the AI’s solution is reliable?
• Can I safely integrate the code into a real system?

LeetCode 255: Verify Preorder Sequence in Binary Search Tree

preorder = [5, 2, 1, 3, 6]

True

      5
     / \
    2   6
   / \
  1   3

preorder = [5, 2, 6, 1, 3]

False

6

5

1

BST Preorder Rule

• All values in the left subtree are smaller than the root.
• All values in the right subtree are greater than the root.

root -> left subtree -> right subtree

Stack-Based Solution

Python Solution

class Solution:
    def verifyPreorder(self, preorder: List[int]) -> bool:
        stack = []
        lower_bound = None

        for value in preorder:
            if lower_bound is not None and value < lower_bound:
                return False

            while stack and value > stack[-1]:
                lower_bound = stack.pop()

            stack.append(value)

        return True

Small Improvement Over the Original Code

if prev_root and item < prev_root:

0

if lower_bound is not None and value < lower_bound:

Walkthrough: Valid Example

[5, 2, 1, 3, 6]

stack = []
lower_bound = None

5

stack = [5]

2

2 < 5

stack = [5, 2]

1

1 < 2

stack = [5, 2, 1]

3

3 > 1

1

lower_bound = 1
stack = [5, 2]

3 > 2

2

lower_bound = 2
stack = [5]

3 < 5

3

stack = [5, 3]
lower_bound = 2

2

2

6

6 > 3

3

lower_bound = 3
stack = [5]

6 > 5

5

lower_bound = 5
stack = []

6

stack = [6]

True

Walkthrough: Invalid Example

[5, 2, 6, 1, 3]

5

stack = [5]

2

stack = [5, 2]

6

6 > 2

2

lower_bound = 2
stack = [5]

6 > 5

5

lower_bound = 5
stack = []

6

stack = [6]

5

5

1

1 < lower_bound
1 < 5

False

Why This Works

We have finished this node’s left subtree and are now entering its right subtree.

Time and Space Complexity

O(n)

O(n)

[5, 4, 3, 2, 1]

Follow-up: Constant Space Solution

class Solution:
    def verifyPreorder(self, preorder: List[int]) -> bool:
        lower_bound = float("-inf")
        i = -1

        for value in preorder:
            if value < lower_bound:
                return False

            while i >= 0 and value > preorder[i]:
                lower_bound = preorder[i]
                i -= 1

            i += 1
            preorder[i] = value

        return True

i

stack.append(value)

i += 1
preorder[i] = value

stack.pop()

lower_bound = preorder[i]
i -= 1

• Time complexity:

  O(n)

• Extra space complexity:

  O(1)

Final Takeaway

In preorder traversal of a BST, once we enter the right subtree of a node, all future values must be greater than that node.

Introduction to Combinatorial Mathematics (2): Catalan Numbers

What Are Catalan Numbers?

Why Catalan Numbers Matter

• objects must be built in a balanced way,
• paths must stay within a boundary,
• pairings cannot cross,
• a structure can be split into independent left and right parts.

Some Important Catalan Formulas

Closed Form

Equivalent Difference Form

Recursive Formula

Generating Function

Asymptotic Growth

Classic Use Cases of Catalan Numbers

1. Valid Parentheses

((())) (()()) (())() ()(()) ()()() 

2. Binary Tree Shapes

3. Triangulations of a Polygon

4. Stack Permutations

5. Non-Crossing Handshakes or Pairings

Grid Walking Without Crossing the Diagonal

The Problem

• one step to the right, or
• one step upward.

The Restriction

Why This Matches the Parentheses Problem

• right step corresponds to an opening parenthesis,
• up step corresponds to a closing parenthesis.

Example: n = 3

The Reflection Principle Idea

• all paths from (0,0) to (n,n), and then
• subtract the bad paths that cross above the diagonal.

A Small Table of Catalan Numbers

How to Recognize a Catalan Problem

• balanced expressions,
• valid prefixes,
• non-crossing pairings,
• paths constrained by a diagonal or boundary,
• recursive splitting into left and right parts.

Conclusion

• valid parentheses sequences,
• binary tree shapes,
• polygon triangulations,
• non-crossing pairings,
• stack-valid sequences,
• grid paths that do not cross the diagonal.

Key Formulas Summary

What “touch” Should Do

• Creates an empty file if it doesn’t exist
• Updates the “Last modified” timestamp if it does exist
• Works with multiple file paths
• Accepts wildcards like *.txt
• Does not print noisy output unless you want it to

Quick One-Off Touch (Single File)

if (Test-Path .\file.txt) { (Get-Item .\file.txt).LastWriteTime = Get-Date } else { New-Item -ItemType File -Path .\file.txt | Out-Null }

A Linux-Compatible touch Function (Multiple Files + Wildcards)

• Accepts one or more paths
• Expands wildcards
• Updates timestamps for existing files
• Creates missing files (including parent folders if needed, optional)
• Doesn’t modify file contents

function touch { [CmdletBinding()] param( [Parameter(Mandatory=$true, ValueFromRemainingArguments=$true)] [string[]] $Path,
    # Optional: create parent directories if missing
    [switch] $MakeDirs
)

$now = Get-Date

foreach ($p in $Path) {

    # Expand wildcards (e.g. *.txt). If no match, treat as literal.
    $expanded = @(Get-ChildItem -LiteralPath $p -ErrorAction SilentlyContinue)

    if ($expanded.Count -gt 0) {
        foreach ($item in $expanded) {
            if ($item.PSIsContainer) {
                continue  # skip directories (Unix touch can differ; this is safer)
            }
            $item.LastWriteTime = $now
        }
        continue
    }

    # No wildcard matches; treat as a literal file path
    if (Test-Path -LiteralPath $p) {
        $item = Get-Item -LiteralPath $p
        if (-not $item.PSIsContainer) {
            $item.LastWriteTime = $now
        }
        continue
    }

    # Create the file (optionally create parent folders)
    if ($MakeDirs) {
        $parent = Split-Path -Parent $p
        if ($parent -and -not (Test-Path -LiteralPath $parent)) {
            New-Item -ItemType Directory -Path $parent -Force | Out-Null
        }
    }

    New-Item -ItemType File -Path $p -Force | Out-Null
}

}

Examples

touch .\hello.txt

touch .\a.txt .\b.txt .\c.txt

touch *.log

touch .\logs\2026\app.log -MakeDirs

Install touch Permanently (Add to Your PowerShell Profile)

notepad $PROFILE

Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

Optional: Make It Feel More Like Linux

Set-Alias -Name t -Value touch

Notes and Gotchas

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
}

Click "Images" from Left Navigation Bar

Select Style and then a local Image to Upload

Prompt (Automatic)

Original Picture

Generated Image Result

Syntax

template<class InputIt1, class InputIt2, class T,
         class BinaryOp1, class BinaryOp2>
T transform_reduce(InputIt1 first1, InputIt1 last1,
                   InputIt2 first2, T init,
                   BinaryOp1 binary_op1,
                   BinaryOp2 binary_op2);

template<class InputIt, class T,
         class BinaryOp1, class UnaryOp>
T transform_reduce(InputIt first, InputIt last,
                   T init,
                   BinaryOp1 binary_op1,
                   UnaryOp unary_op);

• It applies a unary transformation to each element (optional).
• Then it reduces all results using a binary operation like sum, product, or custom combination.
• It can work in parallel with execution policies in C++17/20.

Example 1: Sum of squares

#include <iostream>
#include <vector>
#include <numeric>
#include <execution>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    int sum_of_squares = std::transform_reduce(
        std::execution::seq,   // sequential execution
        numbers.begin(),
        numbers.end(),
        0,                     // initial value
        std::plus<>(),    // binary operation (sum)
        [](int x){ return x*x; } // unary transform (square)
    );

    std::cout << "Sum of squares: " << sum_of_squares << std::endl;
    return 0;
}

Example 2: Dot product of two vectors

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> a = {1, 2, 3};
    std::vector<int> b = {4, 5, 6};

    int dot_product = std::transform_reduce(
        a.begin(), a.end(),
        b.begin(),
        0  // initial value
    );

    std::cout << "Dot product: " << dot_product << std::endl;
    return 0;
}

Example 3: Parallel transform_reduce

#include <iostream>
#include <vector>
#include <numeric>
#include <execution>

int main() {
    std::vector<double> numbers(1'000'000, 1.5);

    double sum = std::transform_reduce(
        std::execution::par,  // parallel execution
        numbers.begin(),
        numbers.end(),
        0.0
    );

    std::cout << "Parallel sum: " << sum << std::endl;
    return 0;
}

Key Points

• transform_reduce avoids creating an intermediate container for the transformed values.
• It supports sequential and parallel execution policies.
• Two main forms: single range with unary transform, or two ranges for pairwise operations (like dot product).
• Initial value is required to correctly handle empty ranges.

Change via WordPress Settings

1. Go to WordPress Admin → Settings → Reading.
2. Look for “For each article in a feed, show”.
3. You’ll see two options: Full text and Summary
4. Select Full text to ensure /feed outputs the full post content.
5. Click Save Changes.

Change via Theme (if settings not respected)

// Force RSS feed to show full content
function my_full_feed_content($content) {
    return get_the_content();
}

add_filter('the_excerpt_rss', 'my_full_feed_content');
add_filter('the_content_feed', 'my_full_feed_content');

Change via Plugins

One year later, back at Nvidia: I really got stronger From rejection to progress: my two encounters with Nvidia Interviews are truth mirrors: each one makes me clearer about myself Rejection is not the end, but the start of coming back stronger Why I only interview at big tech: growth notes from two Nvidia interviews Two rounds at Nvidia showed me my weak spots How a big-tech rejection became my growth fuel The real growth path for engineers: keep interviewing, keep upgrading My two clashes with Nvidia: evolving from k8s to C++ 90-minute technical interview, three days of waiting: goodbye Nvidia, and thank you That Nvidia rejection helped me fix the most critical gaps Nvidia, I’m coming again — this time I’m tougher Big-tech interviews: an ongoing practice of upgrading After two Nvidia rejections, I’m getting stronger and stronger

Unfortunately the team have decided not to move forward with your application. The feedback was positive however there were just other candidates whose skillset was a stronger match.

Q: Is there a cool down period before I can apply to another position? A: No there isn’t, you can apply for as many roles as you wish.