Forem: Delean Mafra

🚀 Extension Project III: from spreadsheet chaos to a web app

Delean Mafra — Sun, 04 Jan 2026 19:37:09 +0000

So here’s the deal: this semester I jumped into a real-world challenge with a partner company. Their entire financial and inventory management was stuck in spreadsheets. Manual entries, repetitive calculations, errors everywhere, zero visibility for decision-making. Basically… a nightmare.

And I thought: seriously, in 2025 we’re still doing this?
Time to fix it.

What I built
A Python + Flask web app that merges finance and inventory in one place.
No more copy-pasting numbers. Everything’s automated, reliable, and visualized in dashboards that actually make sense.

Key features
Simple interface for income and expense entries

Customizable categories and payment methods

Automatic integration: purchases → expenses, sales → income

Dashboards with 5 core visualizations

Lightweight JSON persistence + client-validated prototypes

Real impact
Hours saved from manual data entry

Fewer errors, more trust in the numbers

Instant visibility of cash flow and spending patterns

Direct support for day-to-day decisions

Tech stack
Python, Flask, Jinja2, Bootstrap, Chart.js..
Nothing fancy — just tools that work.

📂 Repo: https://github.com/Delean-Mafra/pex3
📄 Full report: https://delean-mafra.github.io/pex3

🎯 The takeaway
This wasn’t just about coding. It was about proving that tech can turn clunky processes into something agile and strategic.
Spreadsheets are fine… until they’re not.

Codewars: the challenge platform that transforms practice into mastery for developers

Delean Mafra — Sun, 14 Dec 2025 23:15:44 +0000

Why Use Codewars

Codewars is a community-created challenge-based programming practice platform (kata) designed to help developers improve their skills through hands-on exercises, instant feedback, and solution review. The platform supports over 50 languages, allows training with automated browser tests, and encourages continuous improvement through difficulty levels and a progression system.

What it is and how it works

Kata and Dojo
The exercises in Codewars are called kata: small problems focusing on specific techniques (algorithms, data structures, string manipulation, etc.). When solving a kata, you receive immediate feedback through automated tests, can submit multiple approaches, and compare solutions from other users to learn alternatives and optimizations.

Levels and Progression
Each kata has a level (e.g., 8 kyu to 1 kyu) indicating complexity. Solving challenges earns experience points (XP) and improves your ranking and honor in the community, creating a cycle of motivation to tackle increasingly difficult problems.

Main Features

Online editor with integrated tests: write and run code directly in the browser; TDD tests validate your solution as you develop.
Multi-language support: choose from dozens of languages to practice or learn new syntaxes and paradigms.
Collections and paths: sets of kata organized by theme or level (e.g., collections for beginners) that guide learning sequentially.
Community discussions and solutions: after solving (or skipping) a kata, you can view and comment on solutions from other developers, which is excellent for learning alternative patterns and techniques.
Ranking, honor, and profile: social metrics that show your progress, comparing you to other members and highlighting contributions and elegant solutions.
Community-based kata creation: users can propose new challenges, keeping the platform updated and diverse.

Benefits for developers

Practical and repetitive learning: solving kata reinforces algorithmic thinking patterns and improves the speed of logical reasoning. Case studies and user reports show that regular practice accelerates the resolution of real-world problems.
Exposure to multiple approaches: comparing solutions allows you to learn idiomatic techniques for each language and optimizations that don't appear in theoretical courses.
Preparation for technical interviews: many kata simulate typical interview problems, making Codewars a useful tool for those seeking technical positions.
Community and informal mentoring: comments, discussions, and reviews function as a peer-to-peer mentoring environment, useful for both beginners and experienced professionals.

How to get started and best practices

Create an account and choose a language. Start with one you already know to focus on logic, or choose a new one to learn through practice.
Start with low-level kata and gradually advance; use collections to follow a structured path.
Read solutions from other users after solving a kata to absorb patterns and more elegant alternatives.
Rewrite your solutions applying learned improvements; repetition and refactoring consolidate learning.
Contribute by creating kata when you are comfortable—this strengthens the community and challenges your ability to formulate clear problems.

Conclusion

Codewars is a practical and social tool for developing programming skills through short challenges, automatic feedback, and interaction with an active community. It is useful for both beginners and professionals who want to keep practicing, learn new languages, or prepare for technical interviews.

Link: http://www.codewars.com/r/DnrkrQ/

The Silent Productivity Killer in Your Coding Workflow (And How I Finally Fixed It)

Delean Mafra — Fri, 12 Dec 2025 01:49:08 +0000

Every developer has that one thing in their workflow that quietly drains hours without us noticing. For some people, it’s context switching. For others, it’s debugging rabbit holes.

For me? It was something embarrassingly simple: re‑reading the same code over and over because I didn’t trust my own structure.

I’d jump between files, scroll endlessly, rewrite functions that already existed, and constantly ask myself: “Wait… didn’t I solve this already?”

Turns out, I wasn’t suffering from lack of skill, I was suffering from lack of architecture discipline.

So I tried something new: a tiny rule that changed everything.

✅ The Rule
Before writing a single line of code, I force myself to answer one question:

“Where does this logic live?”

Not “how do I implement it”, not “what library should I use”, but simply:

Where does this belong in the system?

And suddenly:

My files stopped growing into monsters

My functions became smaller and more intentional

My debugging time dropped dramatically

My future self stopped hating me

It’s wild how much clarity you gain when you treat architecture as a first step, not a cleanup phase.

✅ The Result
I write less code, but ship more features. I spend less time debugging, and more time thinking. And the best part: I finally trust my own codebase again.

When I first started programming, I thought the challenge was just memorizing syntax and frameworks. I quickly realized the real challenge, and the real skill, was solving problems, not just writing code.

Here’s how my perspective shifted over time:

Error Messages Became Teachers
Every runtime exception wasn’t a failure, it was a clue. Instead of getting frustrated I started asking: What exactly is the program trying to tell me? That changed everything.

Thinking Before Typing Saved Time
Writing code without planning is like building a house without a blueprint. Sketching the logic first, even in comments, reduced bugs and made refactors easier.

Debugging Taught Patience and Precision
Debugging isn’t about brute force. It’s about isolation, hypothesizing and verifying. This mindset helped me outside coding too — in databases and backend logic.

Explanation Clarifies Understanding
Writing comments, explaining code to others (or even myself), and blog posts helped me think clearer. Teaching is the best test of understanding.

What I learned is simple:

Programming isn’t about knowing everything, it’s about solving problems with logic, clarity and persistence.

And that’s a skill you carry to every project, system, or language you touch.

If you’ve been feeling that silent productivity drain, try asking yourself that one question before you start typing.

Your future self will thank you — and your git history will look a lot less chaotic.