DEV Community: Ahmed Adawy

Master Python testing with pytest and learn how to build reliable, maintainable automated tests

Ahmed Adawy — Sun, 09 Aug 2026 19:43:15 +0000

Writing Python code is only half of the job.

The other half is knowing that the code continues to work when the project changes.

A function can work perfectly today and break tomorrow after a small refactor.

A new feature can accidentally affect an older one.

A seemingly harmless change can introduce a regression somewhere else.

This is where automated testing becomes essential.

Introducing: Python Testing with pytest

I’ve just published the second capsule in my Ahmed Adawy Tech Capsules series:

Python Testing with pytest — A Practical Guide to Writing Reliable Tests

This capsule is designed as a practical introduction to automated testing with Python’s pytest framework.

It focuses on the concepts developers actually need when moving from manual checking to a repeatable testing workflow.

What you’ll learn

The capsule starts from the fundamentals and progressively builds the testing mindset.

It covers topics such as:

Why automated testing matters

Installing and running pytest

Writing your first test

Assertions

Testing normal behavior

Testing edge cases

Testing exceptions

Verifying exception messages

Writing focused tests

Arrange / Act / Assert

Running individual tests

Understanding pytest output

Structuring tests for real Python projects

And it doesn’t stop at simply showing syntax.

The goal is to understand why these techniques matter and how they fit into a real development workflow.

A simple example

A pytest test can be surprisingly readable:

def test_add():
result = add(2, 3)

assert result == 5

The test tells a story:

Arrange → Act → Assert

Prepare the input.

Execute the behavior.

Verify the result.

That simplicity is one of the reasons pytest has become such a practical choice for Python testing.

Testing failure is testing too

Reliable software isn’t only about successful inputs.

Invalid behavior needs to be tested as well.

For example:

import pytest

def test_divide_by_zero():
with pytest.raises(ValueError):
divide(10, 0)

Now the test verifies that the software doesn’t merely fail — it fails in the expected way.

That’s an important distinction when building dependable applications.

Why I created this capsule

I wanted this capsule to be useful to someone who already knows basic Python but wants to move toward a more professional development workflow.

Instead of treating testing as something added at the end of a project, the capsule presents testing as part of the development process itself.

The bigger idea is simple:

Your tests become a safety net for your code.

The more your project grows, the more valuable that safety net becomes.

📚 The full capsule

The complete capsule goes beyond the introductory material and explores the techniques needed for larger Python projects, including:

Fixtures • Parametrization • Reusable Test Setup • Advanced Exception Testing • Test Organization • Code Coverage • Continuous Integration • Real-World Testing • Professional Testing Practices

The capsule is approximately 45 pages and is part of the growing Ahmed Adawy Tech Capsules series.

🚀 Who is this for?

This capsule is especially useful for:

Python developers

Students learning software engineering

Developers moving from scripts to larger projects

Anyone starting with automated testing

Developers who want to introduce pytest into their workflow

You don’t need to be a testing expert.

You just need a working understanding of Python and a willingness to start testing your code properly.

The bigger goal

This capsule is part of a larger project I’m building:

Ahmed Adawy Tech Capsules

Short, focused technical books designed to turn complex engineering concepts into practical, readable learning material.

One topic.

One focused capsule.

One practical engineering skill at a time.

📖 Python Testing with pytest

A Practical Guide to Writing Reliable Tests

Author: Ahmed Adawy
Series: Ahmed Adawy Tech Capsules
Category: Python / Testing
Level: Intermediate
Length: ~45 pages

If you’re writing Python seriously, automated testing is no longer just a “nice to have.”

It’s part of building software you can trust.

Keep testing. Keep improving. Keep building.

Automating Python Projects with GitHub Actions: A Practical CI/CD Workflow

Ahmed Adawy — Sat, 08 Aug 2026 18:59:52 +0000

I finally published a practical guide to GitHub Actions for Python projects.

GitHub Actions is easy to demonstrate with a simple YAML file.

The harder part is designing a workflow that actually helps a real project.

So I built this capsule around the practical side of CI/CD:

• Setting up Python environments in GitHub Actions
• Managing project dependencies
• Running automated tests with pytest
• Generating test coverage reports
• Building project documentation
• Generating and preserving workflow artifacts
• Organizing workflow steps
• Understanding the execution order of CI jobs
• Building reusable patterns for Python projects

The goal wasn't to write another long DevOps book.

I wanted something closer to a technical micro-book: one focused topic, practical examples, and enough explanation to understand why each part of the workflow exists.

If you're working on a Python project and still run tests, build documentation, or generate artifacts manually, this is the problem this capsule is trying to solve.

📘 GitHub Actions for Python Projects
A Practical Guide to CI/CD Automation

Available on Leanpub:
[Leanpub link]

The source/project materials are also available on GitHub:
https://github.com/adawy20262026-oss/ahmed-adawy-tech-capsules

Python #GitHubActions #CICD #DevOps #SoftwareEngineering #Testing #pytest

Introducing Ahmed Adawy Tech Capsules: A Professional Markdown-to-PDF Publishing Engine Built with Python

Ahmed Adawy — Fri, 07 Aug 2026 15:53:20 +0000

Introducing Ahmed Adawy Tech Capsules..

For the past weeks, I have been building a project that combines technical writing, automation, and software engineering into a single publishing workflow.

Today I'm happy to introduce Ahmed Adawy Tech Capsules.

A Python-powered publishing engine that transforms Markdown documents into professional technical publications.

Why I Built It

Writing technical content is easy.

Publishing it professionally is not.

Most technical writers spend hours formatting documents, creating PDF files, styling pages, generating tables of contents, and maintaining documentation.

I wanted one command to do everything.

Features

Professional HTML rendering
Beautiful PDF generation using WeasyPrint
Automatic cover pages
Automatic Table of Contents
Syntax highlighting powered by Pygments
Metadata support
Modular architecture
Library index generation
Streamlit Web Interface
GitHub Actions CI/CD
Automated testing

Architecture

The project follows a modular architecture.


Markdown

      │

      ▼

Metadata Parser

      │

      ▼

Markdown Parser

      │

      ▼

HTML Renderer

      │

      ├── Cover Renderer

      ├── TOC Renderer

      ├── Content Renderer

      ├── Footer Renderer

      │

      ▼

PDF Generator

      │

      ▼

Professional PDF

Each component has a single responsibility, making the project easy to maintain and extend.

Current Statistics

Python 3.12
54 automated tests
94% test coverage
GitHub Actions CI
MIT License
First Stable Release (v1.0.0)

Technologies

Python
Markdown
WeasyPrint
Pygments
PyYAML
Streamlit
Pytest
GitHub Actions

Open Source

The project is completely open source.

Contributions, ideas, and feedback are always welcome.

GitHub Repository:

https://github.com/adawy20262026-oss/ahmed-adawy-tech-capsules

What's Next

The roadmap includes:

100% test coverage
CLI interface
Multiple themes
EPUB export
PyPI package
Plugin system
AI-assisted publishing

Thank you for reading.

If you enjoy technical writing, Python, or documentation tooling, I'd love to hear your thoughts.

Introducing Ahmed Adawy Tech Capsules: A Professional Markdown-to-PDF Publishing Engine Built with Python

Ahmed Adawy — Fri, 07 Aug 2026 15:43:00 +0000

Introducing Ahmed Adawy Tech Capsules

For the past weeks, I have been building a project that combines technical writing, automation, and software engineering into a single publishing workflow.

Today I'm happy to introduce Ahmed Adawy Tech Capsules.

A Python-powered publishing engine that transforms Markdown documents into professional technical publications.

Why I Built It

Writing technical content is easy.

Publishing it professionally is not.

Most technical writers spend hours formatting documents, creating PDF files, styling pages, generating tables of contents, and maintaining documentation.

I wanted one command to do everything.

Features

Professional HTML rendering
Beautiful PDF generation using WeasyPrint
Automatic cover pages
Automatic Table of Contents
Syntax highlighting powered by Pygments
Metadata support
Modular architecture
Library index generation
Streamlit Web Interface
GitHub Actions CI/CD
Automated testing

Architecture

The project follows a modular architecture.

Markdown
      │
      ▼
Metadata Parser
      │
      ▼
Markdown Parser
      │
      ▼
HTML Renderer
      │
      ├── Cover Renderer
      ├── TOC Renderer
      ├── Content Renderer
      ├── Footer Renderer
      │
      ▼
PDF Generator
      │
      ▼
Professional PDF

Each component has a single responsibility, making the project easy to maintain and extend.

Current Statistics

Python 3.12
54 automated tests
94% test coverage
GitHub Actions CI
MIT License
First Stable Release (v1.0.0)

Technologies

Python
Markdown
WeasyPrint
Pygments
PyYAML
Streamlit
Pytest
GitHub Actions

Open Source

The project is completely open source.

Contributions, ideas, and feedback are always welcome.

GitHub Repository:

https://github.com/adawy20262026-oss/ahmed-adawy-tech-capsules

What's Next

The roadmap includes:

100% test coverage
CLI interface
Multiple themes
EPUB export
PyPI package
Plugin system
AI-assisted publishing

Thank you for reading.

If you enjoy technical writing, Python, or documentation tooling, I'd love to hear your thoughts.

🚀 Beyond pip install: The Invisible Memory Leak Destroying AI Microservices

Ahmed Adawy — Mon, 03 Aug 2026 18:25:58 +0000

There is a specific kind of developer pain that only happens at 2:00 AM.

Your code compiles. Your tests pass with flying colors. You build a sleek Python/AI microservice, write a few clean modules,wrap it up nicely, and push it to production or cloud runtime. Everything looks smooth, the demo works, and for the first few minutes, you feel like a genius.

Then, under real user traffic, the memory consumption starts creeping up. 100MB... 500MB... 1.5GB... Crash. OOMKilled (Out of Memory).

If you are a Computer Science student, AI Engineer, or Software Developer building data & text pipelines, you’ve probably blamed garbage collection, blamed Streamlit, or blamed Python itself.

Here is the truth about what actually broke, and how we solved it.

🛠️ The Problem: Hidden C-Level Memory Leaks in Python Pipelines

When we build AI wrappers or document transformation tools (converting Markdown/HTML to professional PDFs using packages like weasyprint, cairo, or heavy ML models), we rely heavily on C-extensions under the hood.

Python developers trust Python’s Automatic Garbage Collector (gc). But here is the catch:

Python’s garbage collector only manages Python objects. It has ZERO visibility or control over memory allocated at the C-library level (libgobject, libcairo, or C++ bindings).

When your backend processes requests

continuously:

Python creates C-level pointers for rendering or model inference.

The Python object dies after the request finishes.

The C-level memory chunk remains allocated in system RAM because the shared library didn’t explicitly trigger a release.

To the system, your app looks like a memory sponge.

⚡ The Solution: Process Isolation & Defensive Pipeline Design

Instead of fighting C-level garbage collection inside the main runtime thread, the architectural solution lies in Process Isolation & Explicit Context Cleanup.

Here is how to solve it natively in Python:

Isolated Execution via multiprocessing

By offloading heavy rendering or inference tasks into a temporary worker process,

system RAM is forcibly reclaimed by the OS the moment the worker process terminates.

import multiprocessing as mp

def isolated_heavy_task(input_data, output_queue):

# Heavy C-library calls / PDF rendering / Heavy AI inference happens here

result = perform_rendering(input_data)

output_queue.put(result)

def safe_execution(input_data):

queue = mp.Queue()

process = mp.Process(target=isolated_heavy_task, args=(input_data, queue))

process.start()



# Retrieve result and ensure process termination

result = queue.get()

process.join()  # OS automatically frees 100% of C-level RAM here

return result

Explicit Ctypes & Temporary File Flushing

If you are generating heavy PDF artifacts or manipulating raw text buffers:

Never keep binary streams held indefinitely in application memory.

Flush explicitly to /tmp storage and use context managers (with) to enforce clean file descriptor closures immediately after execution.

💡 The Takeaway for Engineers & CS Students

Building software that works on localhost takes a few hours.

Building software that survives real-world edge cases, shared libraries, and server constraints takes real architectural engineering.

Don't just write scripts that execute—build systems that clean up after themselves.

What’s the most frustrating runtime or memory bug you’ve ever had to debug in production? Let's discuss in the comments below! 🛠️

4 Docker Commands I Use Almost Every Day (And You Probably Will Too)

Ahmed Adawy — Tue, 28 Jul 2026 16:24:00 +0000

When I first started using Docker, I kept searching for the same commands over and over again.

Eventually, I realized that I only needed a handful of commands for 90% of my daily work.

Here are the four Docker commands I use the most.

1. Build an Image

docker build -t myapp:v1 .

This command creates a Docker image from your Dockerfile.

I always use version tags instead of latest because it makes deployments easier to track and roll back.

2. Run a Container

docker run -d -p 8080:8080 --name myapp_instance myapp:v1

What this does:

Runs the container in the background
Maps port 8080 on your machine to the container
Gives the container a readable name

Instead of random container IDs, I can simply reference myapp_instance.

3. Monitor What's Happening

docker ps

Shows all running containers.

Need to inspect logs?

docker logs -f myapp_instance

The -f flag streams logs in real time, which is incredibly useful when debugging startup issues.

4. Stop and Remove Cleanly

docker stop myapp_instance && docker rm myapp_instance

One command.

No leftover containers.

No unnecessary clutter.

A Small Habit That Saves Time

I almost never use anonymous containers during development.

Naming containers makes debugging, logging, restarting, and scripting much easier.

It seems like a tiny habit, but it saves a surprising amount of time over the long run.

Quick Reference

docker build -t myapp:v1 .
docker run -d -p 8080:8080 --name myapp_instance myapp:v1
docker ps
docker logs -f myapp_instance
docker stop myapp_instance && docker rm myapp_instance

That's it.

You don't need to memorize dozens of Docker commands.

Master these four first, and you'll already handle most day-to-day Docker workflows with confidence.

If you found this useful, save it for later—you'll probably need these commands again.

Practical Python Implementation: Simulating Lattice-Based Key Generation

Ahmed Adawy — Mon, 27 Jul 2026 21:18:51 +0000

Practical Python Implementation: Simulating Lattice-Based Key Generation
Understanding the mathematical foundation behind post-quantum cryptography using a simple Python implementation.

Why Lattice Cryptography?
Quantum computers threaten many of today's public-key cryptographic systems, including RSA and Elliptic Curve Cryptography.
One of the strongest candidates for replacing them is Lattice-Based Cryptography, the mathematical foundation behind algorithms such as CRYSTALS-Kyber, selected by NIST for the post-quantum era.
Real implementations involve advanced polynomial algebra and high-dimensional lattices.
However, before diving into those complexities, it's helpful to understand the core mathematical intuition.

The Idea
Instead of implementing the complete Kyber algorithm, this educational example demonstrates how a hidden lattice basis can generate a public lattice while keeping the private structure secret.
The example illustrates:
Mathematical vectors

Linear combinations

Public and private lattice bases

Shared secret generation

Why recovering the private basis is computationally difficult

The objective is education - not production cryptography.

Python Example
import random
def vector_add(v1, v2):
return [x + y for x, y in zip(v1, v2)]
def scalar_multiply(scalar, vector):
return [scalar * x for x in vector]
private_basis_v1 = [1, 0]
private_basis_v2 = [0, 1]
scalar_a = 51
scalar_b = 73
public_v1 = vector_add(
scalar_multiply(scalar_a, private_basis_v1),
scalar_multiply(scalar_b, private_basis_v2)
)
secret_multiplier = 142
shared_secret = scalar_multiply(secret_multiplier, public_v1)
print(shared_secret)

What Happens Here?
The script performs the following steps:
Creates a simple private lattice basis.

Produces a transformed public basis.

Simulates a shared secret generated on the public lattice.

Demonstrates the core intuition behind lattice-based cryptography.

Although this example uses only two dimensions, the same concepts scale to hundreds of dimensions in real post-quantum cryptographic systems.

Why This Matters
The security of lattice cryptography does not rely on prime factorization like RSA.
Instead, it depends on the computational hardness of mathematical lattice problems such as:
Shortest Vector Problem (SVP)

Closest Vector Problem (CVP)

Learning With Errors (LWE)

These problems remain difficult even for large-scale quantum computers, making lattice cryptography one of the most promising foundations for future secure communication.

Educational Purpose
This implementation is intentionally simplified to help students and engineers understand the underlying mathematical concepts before studying full post-quantum algorithms such as:
CRYSTALS-Kyber

Dilithium

Falcon

Learning the intuition first makes advanced cryptographic research much easier to approach.

Final Thoughts
Modern cybersecurity is increasingly becoming applied mathematics.
Understanding the mathematics behind cryptographic algorithms is just as important as learning to implement them.
Every secure communication protocol begins with mathematical ideas that can often be explained through surprisingly simple code.

If you enjoyed this article, consider following my work for more content on:
Scientific Python

Computational Mathematics

AI Engineering

Numerical Methods

Cybersecurity

Post-Quantum Cryptography

Python #CyberSecurity #PostQuantumCryptography #LatticeCryptography #Cryptography #Mathematics #Programming #SoftwareEngineering #OpenSource #AI #NumPy #ComputerScience

# Why Every Engineering Student Should Build Simulators Instead of Solving More Equations

Ahmed Adawy — Sun, 26 Jul 2026 23:17:08 +0000

During my journey studying computational engineering, I noticed something surprising.

Most textbooks do an excellent job explaining the mathematics behind engineering problems.

They derive differential equations.

They prove theorems.

They analyze physical models.

But they rarely answer one practical question:

How do we transform those equations into software?

There is a huge gap between understanding an equation and building a simulator that actually solves it.

For example...

A neutron diffusion equation on paper eventually becomes:

• A discretized numerical model
• A sparse matrix
• A linear algebra problem
• A Python implementation
• A working scientific application

That transformation is where real engineering happens.

Writing software forces you to understand every assumption, every approximation, and every numerical decision.

That's why I believe:

Code is the ultimate proof of understanding.

This idea is the motivation behind my current open-source work and technical writing.

I'm building educational projects focused on:

• Scientific Python
• Numerical Methods
• Software Architecture
• AI Engineering
• Reactor Physics

The goal isn't simply to explain theory.

The goal is to transform theory into working software that anyone can study, modify, and improve.

If engineering education is going to evolve, I think we need more simulation projects—and fewer isolated equations on paper.

What do you think?

Should engineering education spend more time teaching students how to build scientific software?

Python #ScientificComputing #AI #Engineering #NumPy #OpenSource #SoftwareArchitecture

Stop Just Solving Equations: How to Build a Live Nuclear Reactor Simulator in Python

Ahmed Adawy — Sat, 25 Jul 2026 11:43:01 +0000

If you've ever opened classics like Introduction to Nuclear Engineering by Lamarsh or Nuclear Reactor Analysis by Duderstadt & Hamilton, you've probably admired the elegance of reactor physics.

You'll derive the neutron transport equation, study diffusion theory, analyze reactor criticality, and work through sophisticated mathematical models.

But the moment you open VS Code, PyCharm, or Jupyter Notebook and try to build even a simple reactor simulator, you encounter something textbooks rarely discuss:

A massive engineering gap.

The gap isn't in the physics.

It's in translating mathematical models into reliable numerical software.

The journey actually looks like this:

Continuous Physics
        ↓
Numerical Discretization
        ↓
Linear Algebra
        ↓
Algorithms
        ↓
Working Python Code

Most classical textbooks master the first step.

Scientific software lives in the last four.

From Differential Equations to Numerical Algorithms

Consider one of the most fundamental equations in reactor physics: the one-dimensional steady-state neutron diffusion equation with an external source.

[
D\frac{d^2\phi}{dx^2}-\Sigma_a\phi+S=0
]

where

D is the diffusion coefficient
φ is the neutron flux
Σa is the macroscopic absorption cross section
S is the external neutron source

Beautiful.

Elegant.

Impossible for a computer to solve directly.

Computers don't understand derivatives.

They understand numbers.

Step 1 — Discretize the Reactor

Instead of treating space as continuous, we divide the reactor into equally spaced nodes.

Using the finite difference approximation,

[
\frac{d^2\phi}{dx^2}
\approx
\frac{\phi_{i+1}-2\phi_i+\phi_{i-1}}{\Delta x^2}
]

the governing equation becomes

[
D
\left(
\frac{\phi_{i+1}-2\phi_i+\phi_{i-1}}
{\Delta x^2}

\right)

\Sigma_a\phi_i
+

S_i

0
]

The differential equation has now become a collection of algebraic equations.

Step 2 — Build a Linear System

Rearranging the terms gives

[

\left(\frac{D}{\Delta x^2}\right)\phi_{i-1}

\left(
\frac{2D}{\Delta x^2}
+\Sigma_a
\right)\phi_i
+

\left(\frac{D}{\Delta x^2}\right)\phi_{i+1}

-S_i
]

Instead of solving calculus,

we solve

[
A\Phi=B
]

where

A is a tridiagonal matrix representing neutron leakage and absorption,
Φ is the unknown neutron flux vector,
B contains the external source.

This is where reactor physics becomes numerical linear algebra.

Step 3 — Solve the System in Python

Once the mathematical model has been transformed into matrix form, implementing the solver becomes straightforward.

import numpy as np

def solve_1d_reactor_flux(core_length,
                          num_nodes,
                          D,
                          Sigma_a,
                          source_strength):

    dx = core_length / (num_nodes - 1)

    x = np.linspace(0, core_length, num_nodes)

    A = np.zeros((num_nodes, num_nodes))
    B = np.zeros(num_nodes)

    leakage = D / dx**2
    center = -(2*leakage + Sigma_a)

    for i in range(1, num_nodes-1):
        A[i,i-1] = leakage
        A[i,i]   = center
        A[i,i+1] = leakage
        B[i]     = -source_strength

    # Vacuum boundary conditions

    A[0,0] = 1
    A[-1,-1] = 1

    flux = np.linalg.solve(A,B)

    return x, flux

Notice something important.

We are not performing matrix inversion.

numpy.linalg.solve() uses optimized LAPACK routines to solve the linear system directly, which is both faster and numerically more stable than explicitly computing an inverse matrix.

That distinction matters in scientific computing.

Where Classical Textbooks and Scientific Software Meet

Today's learning resources usually fall into one of two categories.

Classical reactor physics textbooks

Books by Lamarsh, Duderstadt & Hamilton, and Stacey provide the theoretical foundation needed to understand diffusion theory, neutron transport, reactor kinetics, and nuclear engineering.

They explain why the equations work.

Production simulation codes

Projects like OpenMC, Serpent, and MCNP are industrial-strength scientific codes capable of solving extremely sophisticated neutron transport problems.

They demonstrate how professionals simulate reactors.

However, for many students and software engineers, there is still a missing middle layer:

How do you build a simulator yourself?

How do you translate equations into maintainable Python code?

How do you organize numerical algorithms into software architecture?

That bridge is rarely discussed.

A Different Learning Perspective

Instead of replacing classical reactor physics books, numerical programming complements them.

Resource	Primary Focus
Lamarsh	Reactor physics fundamentals
Duderstadt & Hamilton	Mathematical reactor analysis
Stacey	Advanced reactor engineering
Practical Python implementations	Numerical algorithms and simulator architecture

These aren't competing approaches.

They're different layers of the same discipline.

Physics explains the model.

Numerical analysis transforms the model.

Software engineering turns the numerical method into a maintainable simulator.

Final Thoughts

Writing code forces us to confront every assumption hidden inside an equation.

Boundary conditions.

Grid spacing.

Matrix assembly.

Numerical stability.

Data structures.

Algorithmic complexity.

That is why implementing a physical model is often the deepest form of understanding it.

Equations describe reality.

Algorithms make them computable.

Software makes them useful.

If you're interested in exploring this bridge between reactor physics and practical scientific programming, I've been documenting my own approach in a Leanpub book focused on building reactor simulators from scratch using Python and NumPy.

I hope it helps make the transition from equations on paper to working simulation software a little less intimidating.

Mind the Chasm: Bridging the Gap Between Reactor Physics Equations and Python Simulators

Ahmed Adawy — Sat, 25 Jul 2026 11:40:15 +0000

If you've ever opened classics like Introduction to Nuclear Engineering by Lamarsh or Nuclear Reactor Analysis by Duderstadt & Hamilton, you've probably admired the elegance of reactor physics.

You'll derive the neutron transport equation, study diffusion theory, analyze reactor criticality, and work through sophisticated mathematical models.

But the moment you open VS Code, PyCharm, or Jupyter Notebook and try to build even a simple reactor simulator, you encounter something textbooks rarely discuss:

A massive engineering gap.

The gap isn't in the physics.

It's in translating mathematical models into reliable numerical software.

The journey actually looks like this:

Continuous Physics
        ↓
Numerical Discretization
        ↓
Linear Algebra
        ↓
Algorithms
        ↓
Working Python Code

Most classical textbooks master the first step.

Scientific software lives in the last four.

From Differential Equations to Numerical Algorithms

Consider one of the most fundamental equations in reactor physics: the one-dimensional steady-state neutron diffusion equation with an external source.

[
D\frac{d^2\phi}{dx^2}-\Sigma_a\phi+S=0
]

where

D is the diffusion coefficient
φ is the neutron flux
Σa is the macroscopic absorption cross section
S is the external neutron source

Beautiful.

Elegant.

Impossible for a computer to solve directly.

Computers don't understand derivatives.

They understand numbers.

Step 1 — Discretize the Reactor

Instead of treating space as continuous, we divide the reactor into equally spaced nodes.

Using the finite difference approximation,

[
\frac{d^2\phi}{dx^2}
\approx
\frac{\phi_{i+1}-2\phi_i+\phi_{i-1}}{\Delta x^2}
]

the governing equation becomes

[
D
\left(
\frac{\phi_{i+1}-2\phi_i+\phi_{i-1}}
{\Delta x^2}

\right)

\Sigma_a\phi_i
+

S_i

0
]

The differential equation has now become a collection of algebraic equations.

Step 2 — Build a Linear System

Rearranging the terms gives

[

\left(\frac{D}{\Delta x^2}\right)\phi_{i-1}

\left(
\frac{2D}{\Delta x^2}
+\Sigma_a
\right)\phi_i
+

\left(\frac{D}{\Delta x^2}\right)\phi_{i+1}

-S_i
]

Instead of solving calculus,

we solve

[
A\Phi=B
]

where

A is a tridiagonal matrix representing neutron leakage and absorption,
Φ is the unknown neutron flux vector,
B contains the external source.

This is where reactor physics becomes numerical linear algebra.

Step 3 — Solve the System in Python

Once the mathematical model has been transformed into matrix form, implementing the solver becomes straightforward.

import numpy as np

def solve_1d_reactor_flux(core_length,
                          num_nodes,
                          D,
                          Sigma_a,
                          source_strength):

    dx = core_length / (num_nodes - 1)

    x = np.linspace(0, core_length, num_nodes)

    A = np.zeros((num_nodes, num_nodes))
    B = np.zeros(num_nodes)

    leakage = D / dx**2
    center = -(2*leakage + Sigma_a)

    for i in range(1, num_nodes-1):
        A[i,i-1] = leakage
        A[i,i]   = center
        A[i,i+1] = leakage
        B[i]     = -source_strength

    # Vacuum boundary conditions

    A[0,0] = 1
    A[-1,-1] = 1

    flux = np.linalg.solve(A,B)

    return x, flux

Notice something important.

We are not performing matrix inversion.

numpy.linalg.solve() uses optimized LAPACK routines to solve the linear system directly, which is both faster and numerically more stable than explicitly computing an inverse matrix.

That distinction matters in scientific computing.

Where Classical Textbooks and Scientific Software Meet

Today's learning resources usually fall into one of two categories.

Classical reactor physics textbooks

Books by Lamarsh, Duderstadt & Hamilton, and Stacey provide the theoretical foundation needed to understand diffusion theory, neutron transport, reactor kinetics, and nuclear engineering.

They explain why the equations work.

Production simulation codes

Projects like OpenMC, Serpent, and MCNP are industrial-strength scientific codes capable of solving extremely sophisticated neutron transport problems.

They demonstrate how professionals simulate reactors.

However, for many students and software engineers, there is still a missing middle layer:

How do you build a simulator yourself?

How do you translate equations into maintainable Python code?

How do you organize numerical algorithms into software architecture?

That bridge is rarely discussed.

A Different Learning Perspective

Instead of replacing classical reactor physics books, numerical programming complements them.

Resource	Primary Focus
Lamarsh	Reactor physics fundamentals
Duderstadt & Hamilton	Mathematical reactor analysis
Stacey	Advanced reactor engineering
Practical Python implementations	Numerical algorithms and simulator architecture

These aren't competing approaches.

They're different layers of the same discipline.

Physics explains the model.

Numerical analysis transforms the model.

Software engineering turns the numerical method into a maintainable simulator.

Final Thoughts

Writing code forces us to confront every assumption hidden inside an equation.

Boundary conditions.

Grid spacing.

Matrix assembly.

Numerical stability.

Data structures.

Algorithmic complexity.

That is why implementing a physical model is often the deepest form of understanding it.

Equations describe reality.

Algorithms make them computable.

Software makes them useful.

I hope it helps make the transition from equations on paper to working simulation software a little less intimidating.

Why Raw Python Loops Are Bottlenecking Your AI Models (And How to Fix It)

Ahmed Adawy — Fri, 24 Jul 2026 22:16:02 +0000

Python is undisputed king of the Artificial Intelligence and Machine Learning ecosystem. It’s elegant, highly expressive, and lets us prototype complex architectures in a few lines of code. But Python has a dark, dirty secret that every AI engineer eventually crashes into: Native for loops are devastatingly slow.
When you are preprocessing massive datasets, calculating custom loss functions, or manipulating tensor vectors, throwing a standard Python loop at the problem is like driving a tractor on a highway.
Let’s look at why this happens and how we can achieve a 100x+ speedup using Hyper-Drive vectorization techniques.
The Bottleneck: Why Python Loops Fail at Scale
To understand the latency, we have to look under the hood of the CPython interpreter. Every time a standard Python loop runs:
Dynamic Type Checking: Python checks the data type of the variable on every single iteration.
Interpreter Overhead: The loop overhead itself adds massive bytecode execution lag.
Memory Fragmentation: Appending to standard Python lists doesn't guarantee contiguous memory allocation, destroying CPU cache efficiency.
When dealing with 1,000,000 data points in an AI pipeline, this translates to agonizingly slow execution times.
The Hyper-Drive Solution: Vectorization
Instead of processing elements sequentially (Single Instruction, Single Data), we shift the workload to optimized low-level machine code via NumPy, utilizing SIMD (Single Instruction, Multiple Data) architectures. This allows the CPU (or GPU) to execute operations on entire arrays simultaneously at native C speeds.
The Head-to-Head Benchmark
Let’s put theory into practice. Here is a clean, production-ready benchmark script comparing a traditional raw Python loop against a vectorized implementation.
import time
import numpy as np

Size of the dataset (1 Million elements)

N = 1000000

1. Slow Pure Python Loop Approach

def slow_loop(arr):
result = []
for x in arr:
# Simulating a basic linear mathematical transformation
result.append(x * 2 + 5)
return result

2. Fast Vectorized Implementation

def fast_vectorized(arr):
return arr * 2 + 5

if name == "main":
# Prepare data allocations
data_list = list(range(N))
data_array = np.arange(N)

print("🚀 Running performance benchmarks...")

# Timing the pure python loop
start = time.time()
res_slow = slow_loop(data_list)
end = time.time()
time_slow = end - start
print(f"🛑 Pure Python Loop Time: {time_slow:.4f} seconds")

# Timing the vectorized execution
start = time.time()
res_fast = fast_vectorized(data_array)
end = time.time()
time_fast = end - start
print(f"⚡ Vectorized Hyper-Drive Time: {time_fast:.4f} seconds")

# Calculating the speedup factor
print(f"🔥 Speedup Factor: {time_slow / time_fast:.1f}x Faster!")

The Results: The Numbers Don't Lie
When running this setup on a standard development machine, the output is striking:
Pure Python Loop Time: ~0.0850 seconds
Vectorized Implementation Time: ~0.0007 seconds
Performance Jump: ~120x Faster!
By eliminating the Python interpreter's loop overhead, the computation finishes in a fraction of a millisecond. In a real-world AI pipeline training on gigabytes of data, this optimization saves hours of compute time and slashes cloud infrastructure costs.
Going Deeper: Beyond Vectorization
Vectorization is just the first step. When building high-performance AI architectures, you eventually need to cross the bridge from high-level Python wrappers down to bare-metal hardware optimization, GPU compilation, and custom machine code.
If you want to master the underlying mathematical frameworks and hardware-level algorithms that power ultra-fast AI execution, check out my comprehensive blueprint book on Leanpub:
👉 The Hyper-Drive Algorithms: From Raw Python Formulas to High-Performance GPU & Machine Code
Stop letting unoptimized loops throttle your machine learning models. Vectorize your pipelines, keep your data contiguous, and let the hardware do what it was built to do.

Stop Running Your Docker Containers as Root: A Production-Ready Hardening Guide

Ahmed Adawy — Wed, 22 Jul 2026 10:34:34 +0000

The silent security flaw in your Dockerfile and how to fix it in 30 seconds using Node.js and Linux best practices.
When you’ve finally built your application, tested it locally, wrapped it nicely inside a Docker container, and pushed it to production, it works flawlessly. You feel like a DevOps wizard.
But then, an automated security audit flags your deployment, or worse, a malicious actor exploits a dependency vulnerability and gains absolute control over your host cloud server.
Why? Because of one silent, pervasive mistake: You ran your Docker container as root.
By default, unless specified otherwise, Docker runs every process inside the container with root privileges. If an attacker manages to break out of your application process via a container breakout vulnerability, they instantly inherit root access to your entire virtual private server (VPS).
In this quick guide, we’ll dismantle this problem, fix it from scratch, and show you how easy it is to deploy battle-tested, secure containers.
The Problem: The Naive Dockerfile
Look at this common Dockerfile configuration used by thousands of developers daily:

A standard, but insecure Node.js setup

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000

Trapped! Running implicitly as root

CMD ["node", "server.js"]
If you inspect the running processes inside this container on your VPS, you’ll notice that node server.js is executed by user ID 0 (root). If your app gets compromised, your host system is compromised.
The Solution: Dropping Privileges (Non-Root Hardening)
Fixing this doesn't require complex orchestration tools. It only requires understanding the underlying Linux user environment and leveraging built-in image features. Official images like node already come with a secure, pre-configured non-root user called node.
Here is the production-ready, hardened version of the exact same environment:
FROM node:18-alpine
WORKDIR /app

Copy dependency manifests

COPY package*.json ./

Install production dependencies only

RUN npm ci --only=production

Copy application source code

COPY . .

EXPOSE 3000

The Magic Line: Instantly switch from root to limited privilegesspan_0 span_0

USER node

CMD ["node", "server.js"]
By simply introducing USER node before your execution command, the application drops its root capabilities completely. If a vulnerability is triggered, the blast radius is confined tightly inside a sandboxed, low-privilege environment.

The Production Cleanup & Firewall Layer
Securing your container is only half the battle; you must also secure the Linux environment hosting it. When managing a VPS, ensuring proper networking and storage hygiene is crucial.

1. Hardening the Network (UFW Firewall)
Never leave your server ports completely exposed to the open web. Before launching your containers, restrict incoming traffic using the Uncomplicated Firewall (UFW) to allow only essential administration and web traffic:

Deny everything by default, allow standard management and web portsspan_6 span_6

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp # SSH
sudo ufw allow 80/tcp # HTTP
sudo ufw allow 443/tcp # HTTPS
sudo ufw enable

Reclaiming Disk Space Building multiple versions of images can quickly fill up your server's storage. Run a strict maintenance loop to prune dangling layers, unused containers, and unreferenced volumes: docker system prune -a --volumes Stop Guessing Your Production Configs Modern software development requires moving fast, but local development and production deployments shouldn't feel like two completely different worlds. You shouldn't have to wade through 500 pages of dense theoretical text just to spin up a secure, multi-container architecture. If you want a condensed, zero-fluff reference guide packed with ready-to-use Linux CLI commands, production multi-container docker-compose setups with databases, and ultimate security checklists, check out my latest handbook: 👉 The Production-Ready Docker & Linux Pocket Guide

What is your container security routine? Do you always implement non-root users in your pipelines, or do you rely entirely on cloud-level firewalls to protect your workloads? Let's discuss your deployment setup in the comments below!

DEV Community: Ahmed Adawy

Master Python testing with pytest and learn how to build reliable, maintainable automated tests

Automating Python Projects with GitHub Actions: A Practical CI/CD Workflow

Python #GitHubActions #CICD #DevOps #SoftwareEngineering #Testing #pytest

Introducing Ahmed Adawy Tech Capsules: A Professional Markdown-to-PDF Publishing Engine Built with Python

Introducing Ahmed Adawy Tech Capsules..

Why I Built It

Features

Architecture

Current Statistics

Technologies

Open Source

What's Next

Introducing Ahmed Adawy Tech Capsules: A Professional Markdown-to-PDF Publishing Engine Built with Python

Introducing Ahmed Adawy Tech Capsules

Why I Built It

Features

Architecture

Current Statistics

Technologies

Open Source

What's Next

🚀 Beyond pip install: The Invisible Memory Leak Destroying AI Microservices

4 Docker Commands I Use Almost Every Day (And You Probably Will Too)

1. Build an Image

2. Run a Container

3. Monitor What's Happening

4. Stop and Remove Cleanly

A Small Habit That Saves Time

Quick Reference

Practical Python Implementation: Simulating Lattice-Based Key Generation

Python #CyberSecurity #PostQuantumCryptography #LatticeCryptography #Cryptography #Mathematics #Programming #SoftwareEngineering #OpenSource #AI #NumPy #ComputerScience

# Why Every Engineering Student Should Build Simulators Instead of Solving More Equations

Python #ScientificComputing #AI #Engineering #NumPy #OpenSource #SoftwareArchitecture

Stop Just Solving Equations: How to Build a Live Nuclear Reactor Simulator in Python

From Differential Equations to Numerical Algorithms

Step 1 — Discretize the Reactor

\right)

S_i

Step 2 — Build a Linear System

\left(\frac{D}{\Delta x^2}\right)\phi_{i-1}

\left(\frac{D}{\Delta x^2}\right)\phi_{i+1}

Step 3 — Solve the System in Python

Where Classical Textbooks and Scientific Software Meet

Classical reactor physics textbooks

Production simulation codes

A Different Learning Perspective

Final Thoughts

Mind the Chasm: Bridging the Gap Between Reactor Physics Equations and Python Simulators

From Differential Equations to Numerical Algorithms

Step 1 — Discretize the Reactor

\right)

S_i

Step 2 — Build a Linear System

\left(\frac{D}{\Delta x^2}\right)\phi_{i-1}

\left(\frac{D}{\Delta x^2}\right)\phi_{i+1}

Step 3 — Solve the System in Python

Where Classical Textbooks and Scientific Software Meet

Classical reactor physics textbooks

Production simulation codes

A Different Learning Perspective

Final Thoughts

Why Raw Python Loops Are Bottlenecking Your AI Models (And How to Fix It)

Size of the dataset (1 Million elements)

1. Slow Pure Python Loop Approach

2. Fast Vectorized Implementation

Stop Running Your Docker Containers as Root: A Production-Ready Hardening Guide

A standard, but insecure Node.js setup

Trapped! Running implicitly as root

Copy dependency manifests

Install production dependencies only

Copy application source code

The Magic Line: Instantly switch from root to limited privilegesspan_0span_0

Deny everything by default, allow standard management and web portsspan_6span_6

The Magic Line: Instantly switch from root to limited privilegesspan_0 span_0

Deny everything by default, allow standard management and web portsspan_6 span_6