Forem: Bek Brace

Rediscovering the Joy of Coding — Writing My First Real Program in Pascal

Bek Brace — Sun, 16 Nov 2025 16:36:57 +0000

Rediscovering the Joy of Coding --- Writing My First Real Program in Pascal

There's something magical about going back to the roots.

Hey everyone, Bek here !

As a programmer, I've spent years bouncing between Python, Rust, Go, C#,
JavaScript [when i was a kid in the 80s, it used to be Basic only, on every C64 and Atari] ... the usual modern toolbox. But recently, I felt like
something was missing. I missed that feeling I had as a kid --- typing
code, watching characters move on a screen, feeling like I was building
something with my own hands instead of scaffolding another framework.

So I did something unexpected.

I went back to Pascal.

Why Pascal?

Pascal feels like the programming equivalent of a freshly cleaned desk:
simple, organized, no nonsense.

The syntax is easy to memorize\
It's incredibly readable\
It forces you to think clearly\
And it gives you this warm, retro "I'm actually writing a program" feeling

Writing Pascal makes me feel like a programmer again --- not just a
framework technician bouncing between APIs and config files.

The "Health Checker" Program --- My First Small Project

Before diving into anything big, I wanted a simple project that still
does something: a tiny health checker that calculates BMI and prints a
result.

It was such a small program... but writing it in Pascal was fun.

No fighting the language.\
No hunting for libraries.\
No distracting boilerplate.

Just clean structure and pure logic.

Then I Wrote Something Bigger: RetroJournal

After the health checker, I decided to stretch Pascal a bit --- just
enough to make something playful.

I created a full Retro Journal System with:

A fake boot sequence\
A menu\
A file-based journal\
Search functionality\
Statistics\
Retro green terminal vibes

It's one of those tiny programs that reminds you why you started coding
in the first place.

Video Tutorial

Final Thoughts

This Pascal adventure reminded me of something important:\
Programming is supposed to be fun.

Not stressful.\
Not competitive.\
Not a race to learn the latest tool.

Just fun.

And Pascal --- with its simple structure and old-school charm ---
brought that feeling back for me.

If you've been feeling burned out or nostalgic, try writing a tiny
Pascal program.\
You might surprise yourself.

Git and GitHub setup for Linux and Windows | Full Guide.

Bek Brace — Sat, 15 Nov 2025 18:03:43 +0000

Every time I have a new machine, I need to configure a bunch of stuff, including Git, and I wanted to leave a manual for Linux and Windows users on how to properly connect Git on your machine with GitHub.
Hopefully,this will help.

Setting Up Git + SSH From Scratch on Linux (Debian/Ubuntu) and Windows (Git Bash) --- A Complete Beginner-Friendly Guide

Whether you're starting your coding journey or setting up a fresh
machine, configuring Git with SSH is essential. This guide covers a
clean setup on Linux (Debian-based) and Windows (Git Bash).

🔧 Part 1 --- Install Git

🟦 Linux (Debian/Ubuntu)

sudo apt update
sudo apt install git
git --version

🟦 Windows (Git Bash)

Download Git from https://git-scm.com/install/windows
Run installer with default settings\
Verify:

git --version

👤 Part 2 --- Configure Git (Name + Email)

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --list

🔐 Part 3 --- Generate an SSH Key

Linux

mkdir -p ~/.ssh
chmod 700 ~/.ssh
ssh-keygen -t ed25519 -C "your_email@example.com"
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
cat ~/.ssh/id_ed25519.pub

Windows (Git Bash)

Same commands as Linux.

🔗 Part 4 --- Add the Key to GitHub

Copy output from:

<!-- -->

cat ~/.ssh/id_ed25519.pub

GitHub → Settings → SSH and GPG keys → New SSH key\
Paste and save

🧪 Part 5 --- Test the Connection

ssh -T git@github.com

📦 Part 6 --- Create Your First Repository

mkdir myproject
cd myproject
git init
echo "Hello Git" > readme.txt
git add readme.txt
git commit -m "Initial commit"

🚀 Part 7 --- Push to GitHub

git remote add origin git@github.com:USERNAME/REPO.git
git branch -M main
git push -u origin main

🎉 Final Thoughts

With Git + SSH configured, pushing to GitHub becomes effortless and
secure.

Monads in Haskell

Bek Brace — Sun, 09 Nov 2025 16:51:22 +0000

Monads...
Yeah, I know — it sounds weird the first time you hear it. When I first started learning Haskell about three years ago, the word itself felt mysterious, almost intimidating. Even in my free YouTube course, I don’t think I ever explained it in a way that truly clicked for everyone.

So this time, I wanted to fix that.

In this video and article, I’ll walk you through what Monads actually are — but not by dropping the term on you out of nowhere. We’ll start from the ground up: Functors, then Applicatives, and only then arrive at Monads.
Each step builds naturally on the one before it — and once you see the pattern, it stops being abstract and starts to make sense.

Step 1 — Functors: applying a function inside something

A Functor is any type that can be “mapped over.”

You already know this idea from other languages:
In Python, you’d do [x * 2 for x in numbers].
In Haskell, it’s fmap (*2) (Just 10) → which gives Just 20.

The wrapper (Maybe) stays the same — you just apply a function inside it.
That’s all a Functor is: a context you can apply a function to, without unwrapping it.

Step 2 — Applicatives: applying a wrapped function to a wrapped value

Applicatives go one step further.
Imagine having both the function and the value wrapped:
Just (2) <> Just 10 → gives Just 20.

It’s basically saying:

“I’ve got a boxed function and a boxed value. Apply one to the other.”

And when something’s missing (Nothing), the whole thing fails gracefully.
Applicative also gives us pure, which just lifts a plain value into a context, like:
pure 5 → Just 5.

Step 3 — Monads: chaining things that return wrapped results

Now comes the big one — Monads.
They let you chain functions that each return their own wrapped result.

For example:

safeDivide :: Float -> Float -> Maybe Float
safeDivide _ 0 = Nothing
safeDivide x y = Just (x / y)

Using the “bind” operator (>>=), we can write:

Just 100 >>= (\x -> safeDivide x 2) >>= (\y -> safeDivide y 5)
-- Just 10.0

If any step returns Nothing, the whole chain stops.
So Monads are basically a clean, composable way to handle context — whether that’s “might fail,” “has side effects,” or “depends on previous results.”

And if you prefer cleaner syntax, do notation does the same thing with less noise.

Wrapping up

Functor → apply a function inside a context

Applicative → apply a wrapped function to a wrapped value

Monad → chain functions that return wrapped values

That’s it — the scary word hides a very simple pattern.

You’ll see it everywhere in Haskell: Maybe, IO, Either, List — all of them are Monads. Once you understand one, you’ve got them all.

If you want to see this concept click into place, check out the full video — I walk through everything live in GHCi with examples and visuals.

I used Python to Analyze Customer Payment Behavior

Bek Brace — Sun, 21 Sep 2025 16:43:22 +0000

As a Credit Manager / Analyst, a big part of my role is to conduct monthly or semi-monthly calls with management, explaining the payment status of our customers. It's crucial for management to understand who’s paying on time, who’s late, and why.

In the past, I relied on VBA macros to automate some reporting tasks. While these macros served their purpose, I wanted something more powerful and flexible—something that could not only help me but also anyone else who wants to analyze customer payment behavior efficiently.

Building a Python Tool for Payment Analysis

I started by creating a Python application that can analyze top overdue companies, identifying those who haven’t paid and the reasons behind it. The goal was to provide clear insights in a way that’s both practical and actionable for management.

But I didn’t stop there. I wanted to take it a step further.

Predicting Late Payments with Machine Learning

Complementing the overdue analysis, I built a predictive model to anticipate which customers might delay payments in the future. This is incredibly important—arguably crucial—for management to plan cash flows, allocate resources, and proactively address potential issues.

By combining Python analytics with machine learning predictions, this tool goes beyond reporting: it provides foresight into customer behavior, helping management make more informed decisions.

Check It Out

I’ve shared the full project on GitHub, along with a video where I walk through the tool in great detail, explaining both the code and the thought process behind it:

GitHub Repo: https://github.com/BekBrace/customer-payment-analysis

Video Walkthrough:

So, whether you’re a process lead, team lead, , data enthusiast, or Python developer, I think that this project can show how you can combine analytics and machine learning to turn raw data into actionable insights. Cheers -

All I need is ... the laptop screen!

Bek Brace — Fri, 19 Sep 2025 06:00:53 +0000

Why I Ditched the Second Monitor

What follows is purely personal—your setup might be perfect for you. But if any of this resonates, I’d be glad.

My studio is a 30-square-meter space in the heart of Łódź, Poland. For five years I’ve been building projects, recording tutorials, and designing courses with a big external monitor paired to my laptop. It felt efficient—until I noticed something odd.

I wasn’t coding so much as transcribing. I’d park my script or reference code on the second screen and spend entire sessions swivelling my head left to right thirty-plus times a minute, copying line after line. If that second screen went dark, I’d panic. My own thinking slowed.

The dependence started to feel like the way we lean on AI tools. A calculator helps with a complex equation, sure, but it doesn’t replace understanding. ChatGPT can be a spark, not a stand-in. My extra monitor had become a stand-in.

Last week I unplugged it. Now it’s just me and the laptop. Notes live on an iPad or a sheet of paper when I need them. And something shifted: I write from memory, plan in my head, and feel my brain working instead of my eyes darting. The simple act of getting stuck—sitting with a problem—feels good again.

This isn’t the first time I’ve been reminded that the hard way matters. From 2009 to 2011 I worked for a Japanese company in Algeria. One day I made a tiny mistake—an extra dot on a document. My manager, Yuki Takahashi (“Yuki” means snow in Japanese), looked at me and said:

“Amir-san, don’t take the easy way. Perfect what you can. The easy way is bad; the hard way pays off.”

Those words never left me. Shortcuts can feed you like junk food: satisfying now, costly later.

So here I am, back to a single screen. It’s slower, and that’s the point.

How about you? Do you thrive with a wall of monitors, or does less help you think more?

Thanks for reading—stay safe, and see you next time.

Get in touch:
X -> https://x.com/BekBrace
YT -> https://www.youtube.com/@BekBrace

The thing is ... I love programming !

Bek Brace — Wed, 10 Sep 2025 16:56:49 +0000

I live in Poland, and there are 60,000 tech companies in Poland, including about ten "unicorns" (private companies valued at over $1 billion).
After several months since the so-called "AI drama," and after watching how 37% of Polish companies reported laying off staff after implementing AI or automation in the past year, and managed to eliminate nearly 27% of tech jobs in the United States between 2021 and 2024, I’ve come to a personal conclusion: I love programming too much to let any of that truly matter. Whether Mr. AI exists or not is irrelevant to me.

The truth is, it doesn’t make much of a difference if AI takes over jobs across the globe. My love for coding is not rooted in competition, productivity, or even recognition. It’s rooted in the art itself—the beauty of constructing something from nothing, of breathing logic and structure into a blank file until it becomes a living, functioning piece of software. I don’t care if AI systems like ChatGPT, Windsurf, or whatever comes next can do it a hundred times faster and a thousand times better. That’s not the point for me.

For me, engaging in the act of programming—whether it’s building an automation tool, experimenting with machine learning, or simply writing a script that saves me five minutes a day—is one of the purest forms of creation I know. It is, in its own way, a form of poetry made of logic, structure, and imagination. I’d even go so far as to say: even if nobody ever saw it, used it, or appreciated it, the act of creating it would still be worth every second.

Because at the end of the day, programming is not just about utility or outcomes—it’s about expression. Just as a painter doesn’t abandon their brush because a printer can reproduce images more accurately, I won’t abandon code simply because AI can generate it faster. For me, it’s not about being the best or the fastest; it’s about being in love with the craft itself.

And maybe, in a world where machines increasingly take center stage, holding on to that human passion—our irrational love for doing something simply because it feels right—is more important than ever.

Get in touch:
X -> https://x.com/BekBrace
YT -> https://www.youtube.com/@BekBrace

why do developers leave coding today altogether ?

Bek Brace — Sat, 30 Aug 2025 14:43:08 +0000

Bek Brace

Aug 30 '25

Why do they quit coding ?

#coding #chatgpt #programming #webdev

Comments 9

2 min read

[Boost]

Bek Brace — Sat, 30 Aug 2025 14:42:36 +0000

Bek Brace

Aug 30 '25

Why do they quit coding ?

#coding #chatgpt #programming #webdev

Comments 9

2 min read

Why do they quit coding ?

Bek Brace — Sat, 30 Aug 2025 09:10:41 +0000

This is a question I’ve been wrestling with for a while—and at some point, I realized I’d already fallen into the trap myself. The AI trap. It’s one of the biggest reasons so many programmers, YouTube coders, and young startups eventually give up on learning, teaching, or even building.

I’m guilty too. I nearly broke my neck from the fall when I first tried tools like Windsurf. You just type what you need in plain English, wait while it generates the code, and every now and then it asks you to approve a feature or a README description. In fifteen minutes, I built something that would have taken me days, maybe weeks, to craft by hand.

So why bother anymore? Why sit down for hours writing an application from scratch—whether for practice, for teaching, or for your colleagues—when the machine can do it in a fraction of the time?

There was a feeling of pride in writing it yourself. Not completely pure pride, since we all used Stack Overflow, trading knowledge with other devs, learning and sharing in the process. That was before ChatGPT, at least. Back then, showing your friends a small app you made to remind you of birthdays or send SMS alerts felt like something. Now? With ChatGPT, Windsurf, Cursor… not so much.

And let’s be honest—how much money is really in it? Do you make a fortune as a software engineer, a programming tutor, or a network architect? Some do. Many don’t. My YouTube channel has 40,000 subs, but views have dropped hard. I barely make $100 a month from it now. Sure, others might pull in $500 to $10K, but is it worth it? And was money ever the reason you started?

Here’s where I stand: programming (not just coding—two very different things) isn’t dead, no matter how many times you’ve heard that over the last couple of years. What’s true is that AI is now a core part of software engineering. The trick is not to depend on it blindly, but to work with it. Partner with the tools. Don’t make them build everything from A to Z. Treat them like an apprentice. Show them what you want to achieve in a code block, or ask them to add something you don’t know how to execute yet. That’s the sweet spot.

In the video, I share the views of Nick White, a programming YouTuber who quit coding. For the most part, I agree with his reasons. I’ve dropped hints here and there about my own views on programming tutoring, but I haven’t spoken openly—at least not yet.

So what do you think?

You can reach me on X >>> https://x.com/bekbrace

Thanks for reading. I’m looking forward to hearing your thoughts on this.

Building a Mental Health Predictor with Machine Learning and FastAPI

Bek Brace — Tue, 19 Aug 2025 12:48:47 +0000

Hey everyone, welcome back! If you’ve been following along with my YouTube channel, you’ll know that in the last video I gave a quick demo of a Mental Health Predictor Machine Learning Project. Today, we’re taking it from idea to code — step by step.

Grab a cup of coffee, fire up your code editor (VS Code in my case), and let’s dive in.

Project Setup

We’ll start by creating a folder for our project. I named mine:

MHP-ML

Inside this folder, we’ll also set up a requirements.txt file to track our dependencies.

On Linux/Mac, you’d usually use the touch command to create files.

On Windows, you can use:

New-Item requirements.txt

Installing Dependencies

Here’s what we’ll need for this project:

FastAPI – our backend framework (0.105.4.1)
Uvicorn – the ASGI server to run FastAPI (0.24.0)
Streamlit – for the front-end interface
Pandas – data handling (1.3.x)
Scikit-learn – machine learning (1.3.2)
NumPy – numerical computations
SQLAlchemy – ORM for database handling
SQLite – lightweight database for storage
Python-multipart – for form data handling in FastAPI

Once the requirements.txt is ready, we’ll install everything inside a virtual environment.

Why a virtual environment?

It isolates the project dependencies so they don’t conflict with other Python projects on your machine. In JavaScript, this happens automatically with node_modules, but in Python we handle it explicitly.

To activate the environment with pipenv:

pipenv shell
pipenv install -r requirements.txt

Project Structure

Here’s a clean project layout:

MHP-ML/
│── requirements.txt
│── main.py
│── models.py
│── source/
    │── app.py       # FastAPI backend
    │── frontend.py  # Streamlit frontend

main.py → Entry point for the app, runs the FastAPI server
models.py → Database models with SQLAlchemy
app.py → FastAPI routes (backend logic)
frontend.py → Streamlit interface

main.py (Entry Point)

This file is short and simple. We run our FastAPI application with Uvicorn:

import uvicorn

if __name__ == "__main__":
    uvicorn.run("source.app:app", host="0.0.0.0", port=8000, reload=True)

Here’s what happens:

"source.app:app" → Tells Uvicorn to look for app inside source/app.py
host="0.0.0.0" → Makes it accessible from your network
port=8000 → Default port
reload=True → Auto-restarts the server on code changes (great for development)

Setting Up the Database (models.py)

We’ll use SQLAlchemy + SQLite for simplicity. This will allow us to store both user inputs and the predictions generated by our ML model.

from sqlalchemy import Column, Integer, String, DateTime, create_engine
from sqlalchemy.orm import declarative_base, sessionmaker
from datetime import datetime

# Base class for our models
Base = declarative_base()

# Database engine (SQLite local file)
engine = create_engine("sqlite:///health_predictions.db")

# Session maker
SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)

# Example table
class HealthData(Base):
    __tablename__ = "health_data"

    id = Column(Integer, primary_key=True, index=True)
    user_input = Column(String, nullable=False)
    prediction = Column(String, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)

This sets up:

A health_data table
Primary key id
user_input and prediction columns
A timestamp for when the record was created

Next Steps

With the foundation laid out:

Backend (FastAPI) will handle API requests
Frontend (Streamlit) will let users interact with the model
Machine Learning model will be integrated using Scikit-learn

In the next part, we’ll connect the dots: load a trained ML model, pass inputs from Streamlit to FastAPI, and store predictions in the database.

GitHub Repo

The full code for this tutorial is available on https://github.com/BekBrace/ML-MentalHealth-Predicator . Feel free to clone it, experiment, and customize it however you like.

Final Thoughts

This project combines multiple layers of modern Python development:

Web APIs with FastAPI
Interactive dashboards with Streamlit
Databases with SQLAlchemy + SQLite
Machine learning with Scikit-learn

It’s a practical way to learn how all these pieces fit together into a real-world application.

GO Full Course

Bek Brace — Thu, 27 Mar 2025 19:16:38 +0000

Hey everyone,

I'm thrilled to announce the launch of my brand-new Go programming full course on YouTube! 🎉

Go Version

I am using Go Version 1.22.

About Me

For those who don't know me, I'm Amir, a passionate software developer and educator who loves diving into new programming languages and sharing my knowledge with the community. Over the past few months, I've been working hard on creating a comprehensive Go course that will take you from a complete beginner to a confident Go developer.

Why Learn Go?

Go (or Golang) is an amazing language known for its simplicity, performance, and powerful concurrency model. It's widely used for backend development, cloud computing, networking, and more. Learning Go can open up many opportunities, and this course is designed to make the process smooth and enjoyable for you.

What You’ll Learn

✅ Detailed explanations of Go’s core concepts

✅ Hands-on coding examples to reinforce learning

✅ Best practices and tips to write clean and efficient Go code

Check it out here:

👉 Watch the full course on YouTube

I'm really excited to share this journey with you. Don't forget to subscribe to my channel, leave a comment, and let me know what you think! Your feedback is invaluable and helps me create even better content for you.

See you in the course! :-)

Best,
Amir

Why I'm hooked on Rust 🦀 ?

Bek Brace — Tue, 25 Feb 2025 19:08:45 +0000

Hey, what's going on everyone? 👋

This is Amir, and today I want to talk about something that's been taking over my programming brain—Rust. If you've been following me for a while, you know I love diving deep into languages, breaking things down, and figuring out how they actually work. But Rust? Rust is different. This language is not just another tool in the box for me. It’s something I’ve genuinely grown attached to, and I want to tell you why.

🧠 Rust Is More Than Just Code

Rust is not just about writing code. It’s a mindset. It’s about thinking in ownership, borrowing, and lifetimes. And yeah, I know that sounds like a lot of jargon, but once you get it, it clicks, and you start seeing code differently [at least that's what I get as feedback from my students who took my Rust course]. It forces you to write better software, and honestly, that’s what keeps me coming back to it.

This is my last Rust project:

🔥 How I Got Into Rust

Like most programmers, I was curious. I kept hearing about its safety, speed, and memory efficiency. No more segfaults? Sounds like a dream come true! At first, it felt strict, but over time, I realized Rust is just trying to make me a better programmer.

🏗️ Ownership & Borrowing

The biggest shift for me was ownership. Unlike garbage-collected languages, Rust doesn’t have a background process cleaning up memory. Instead, it enforces strict rules about who owns what and when. This might sound annoying at first, but it makes you super intentional about handling data.

🚀 The Ecosystem Rocks

Rust's tooling is top-tier:

Cargo 📦 - Probably the best package manager I’ve ever worked with.
Rust’s Documentation 📚 - Clear, concise, and actually useful.
Rust Community 🤝 - One of the friendliest dev communities out there.

And let’s talk about performance. Rust is as fast as C and C++, but with none of the memory management nightmares. You get low-level control and high-level safety.

🐧 Interesting Linux & Rust Facts

💡 Linux & Rust: Did you know that parts of the Linux kernel are being rewritten in Rust? This is huge because it brings Rust’s memory safety guarantees to one of the most critical pieces of software in the world!

💡 Rust is the Most Loved Language: According to Stack Overflow’s developer survey, Rust has been the most loved language for several years in a row. Once you start using it, you understand why!

💡 Linux Powers the World: Over 90% of the world’s supercomputers, servers, and cloud infrastructure run on Linux. And now, Rust is playing a growing role in its future!

⚡ Final Thoughts

Rust isn’t just another language to me. It’s a game-changer. It’s changed how I think about programming and made me more conscious of how I write code. If you haven’t tried it yet, I highly recommend it. But fair warning—you might just get hooked like I did. 😉

Let me know what you think about Rust! Have you tried it yet? Drop a comment and let’s talk.

🚀 Until next time—keep coding, keep building, and I’ll catch you in the next one!