DEV Community: S.Busienei

Hadithi: Speak with your cultural legends e.g. La Llorona and Luanda Magere

S.Busienei — Sat, 31 Oct 2026 11:09:35 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

In my community, stories have always been passed down through oral narratives. Many would sit by the fire and listen to the stories of old, told from one generation to another. The fire was not only a source of warmth. It became a place where children learned who they were, where elders were heard, and where
people who had lived long before us could still feel close.

With changing times (and the changing climate) sitting together by the fire has become less attainable. When those moments disappear, we risk losing more than stories. We can lose names, warnings, humour, courage, and the small details that connect us to where we come from.

I kept wondering: if our gathering places are changing, can we create a new kind of place where these stories can still be encountered?

That question became Hadithi, an immersive portal into oral tradition.
Visitors do not simply read a summary. They enter a legend's landscape, meet a conversational interpretation of its central character, and ask questions using text or their voice.

hadithi-zciw.onrender.com

The portal now opens onto two complete destinations:

Kenya (Africa), where visitors travel to the Kano Plains and meet a conversational interpretation of Luanda Magere from Luo oral tradition;
Mexico (Latin America), where visitors enter a moonlit river landscape shaped around the regional tellings of La Llorona.

The interface labels Luanda as a conversational interpretation from oral tradition. La Llorona is visibly marked as a research draft requiring cultural review, and the experience does not merge. The sources are from approved literal devices (e.g. museum records) and wikipedia as a minor source.

Demo

Live demo: https://hadithi-zciw.onrender.com/
Video demo:

Code

SBusienei / hadithi

Immersive, source-aware oral traditions portal

Hadithi

Hadithi is an immersive, source-aware oral traditions portal. Its launch experiences are:

Luanda Magere — Kenya, Africa
La Llorona — Mexico and Latin America

Visitors enter a legend's landscape, ask questions by text or microphone, and see the sources and regional tellings behind each answer.

Experience preview

Luanda Magere speaks in the first person from the Kano Plains experience, with text, microphone and destination controls kept visible.

La Llorona appears in the river environment beside the English/Spanish chat with the cultural-review status visible in the interface.

Current prototype

Three.js globe journey with labelled Kenya and Mexico destination cards
User-triggered procedural airship engine, wind, arrival, plains and river audio
Kano Plains landscape with a licensed, rigged Luanda Magere character moving sunlight and shadow
La Llorona moonlit riverbank with water, mist, reeds, procedural ambience, an animated character, and bilingual source-grounded text conversation
First-person, source-grounded Luanda Magere conversation in English and Kiswahili
…

View on GitHub

The main implementation areas are:

app/main.py — FastAPI routes, grounded generation, schema validation and deterministic fallbacks;
app/static/portal.js — Three.js scene, character interaction, chat, world destinations, airship transition audio, conversation memory, microphone recording and Kano Plains ambience;
app/static/la-llorona-environment.js — moonlit river, adapted character, bilingual chat and procedural river ambience;
app/services/transcription.py — faster-whisper CPU transcription;
app/content/luanda_magere.json — approved narrative passages;
app/content/luanda_magere_sources.json — source registry and editorial safeguards;
app/content/la_llorona.json and app/content/la_llorona_sources.json — regional narrative pack, source registry and cultural safeguards;
scripts/adapt_la_llorona_model.py — reproducible Blender adaptation and idle-animation export;
tests/test_app.py — grounding, fallback, conversation and route tests.

How I Built It

The immersive portal

The browser begins with a globe suspended in a dark portal. Two readable
destination cards sit below it:

Kenya — Luanda Magere
Mexico and Latin America — La Llorona

Choosing Kenya moves the camera toward the world and reveals the Kano Plains.
Choosing Mexico opens a separate moonlit river environment. Both journeys begin with a short Web Audio transition built from filtered noise and oscillators. It sounds like an airship engine, rising wind and an arrival tone, but no audio file is downloaded and autoplay rules are respected because the sound begins
from the visitor's click.

Luanda faces the visitor beside a chat surface. The moving sun changes the direction of his shadow, turning a central part of the legend into something the visitor can explore.

La Llorona stands farther downriver with her Mournful_Idle animation. Mist, reeds, reflections and restrained moonlight build the atmosphere without turning the experience into a generic horror scene. Her conversation remains text-first because the available synthetic voices did not sound natural enough
for the character.

Voice input

Visitors can type a question or record it using MediaRecorder. FastAPI sends the recording to the open faster-whisper base model using CPU INT8 inference.

During local measurement:

the first transcription completed in approximately 8.54 seconds;
a warm transcription completed in approximately 4.67 seconds.

Natural spoken output is intentionally disabled until a reliable neural text-to-speech provider is available. I preferred readable chat over silently falling back to a robotic browser voice.

Open-model conversation

The live experience currently uses
@cf/meta/llama-3.2-3b-instruct through Cloudflare Workers AI's
OpenAI-compatible endpoint.

For each question, Hadithi sends:

the current question;
a bounded recent conversation history;
approved cultural-source passages;
instructions to preserve uncertainty and oral variants;
a strict schema for the answer, source IDs, topic and gesture.

Conversation history provides context but is explicitly excluded as factual evidence.

The model successfully understood mixed-language input such as:

"Yeah, alikuwa ametoka wapi?"

The selected interface language controls whether Luanda responds in English or Kiswahili.

Grounding and validation

Hadithi checks every returned source ID against an approved registry. A model answer cannot display an invented citation.

If the model returns invalid structured data, cites an unapproved source, claims grounding without evidence, times out, or becomes unavailable, the server returns a reviewed deterministic response. The interface visibly tells the visitor when this happens.

The Luanda source pack includes material associated with:

National Museums of Kenya and Google Arts & Culture;
Kisumu County;
University of Nairobi scholarship on heroic traditions;
University of Nairobi research on orature, heroism and gender.

For La Llorona, Hadithi is building a broader regional source pack using UNAM research, the Smithsonian Latino Center, Guatemala's Ministry of Culture, folklore scholarship, historical associations, and Wikipedia. Wikipedia is identified as a community-edited source in the model context and in displayed
citations rather than being presented as equivalent to peer-reviewed research.

Architecture

Browser
  |- Three.js: destination globe, Kano Plains and moonlit river
  |- Characters: Luanda Magere and animated La Llorona
  |- MediaRecorder: voice questions
  |- Web Audio API: airship transition and procedural ambience
  `- Chat: conversation, citations and provider status

FastAPI
  |- separate approved source packs for each legend
  |- bounded conversation context
  |- strict generation and citation validation
  |- reviewed deterministic fallbacks
  `- faster-whisper transcription

Cloudflare Workers AI
  `- @cf/meta/llama-3.2-3b-instruct

Learning through provider failures

The final architecture came from several failed experiments:

Hugging Face reached Gemma but required inference credits;
free OpenRouter Gemma providers returned capacity errors;
Cloudflare authenticated correctly, but the selected Gemma model was not available to the account;
Llama initially returned prose instead of the required JSON;
a public Chatterbox narration service returned upstream failures.

I switched to an available Llama model, enabled strict structured output, kept provider failures visible, and retained reviewed answers for core questions.

Why Does Open Innovation Matter?

Open models make it possible to build this experience without making one vlosed provider the permanent owner of its future.

The grounding layer, source registry, validation rules and deterministic answers remain part of Hadithi. The conversational model can be hosted through Cloudflare, another compatible provider, or eventually on community-controlled infrastructure.

That matters for cultural technology. A school, museum, archive or community should be able to inspect how a story is represented, replace a model, improve the source pack, and challenge an interpretation.

Open innovation also made failure visible. Instead of disguising unavailable providers or unsupported answers, Hadithi can explain what happened and continue with reviewed material.

My Agent Session

GitHub Copilot helped me iterate through the Three.js experiences, transcription pipeline, provider integrations, structured-output failures, citation checks, conversation memory, Blender character adaptation, mobile layout and test coverage.

The useful part of the agent workflow was not receiving one perfect generated solution. It was being able to test assumptions, inspect failures, replace unreliable providers and preserve the decisions that made the experience safer.

The Spirit of It

The moment the project landed for me was not when the model produced its first answer. It was when the world stopped being a decorative globe and became a choice: Kenya or Mexico, the Kano Plains or a moonlit river.

For a moment, the story no longer felt like a paragraph preserved somewhere on the internet. It felt close again. Someone could speak in English, add a Kiswahili phrase, ask a follow-up, and receive an answer without the experience pretending that every version of the legend was certain.

That matters to me because stories do not remain alive simply because they have been stored. They remain alive when someone is curious enough to ask another question and when another person still cares enough to answer.

Hadithi is built around a simple idea: oral traditions should not become static museum labels, and AI should not rewrite them into confident fiction.

The gathering place may be changing, but the need to listen remains.

Prize Categories

Open-Source AI / main challenge submission
Render partner category — https://hadithi-zciw.onrender.com/
AI application runtime: Render hosts Hadithi’s FastAPI backend and interactive frontend.
Open-model transcription: Runs faster-whisper on CPU for Luanda’s microphone questions.
Source-aware processing: Runs the source-pack selection, structured-answer validation, citation checks, and reviewed fallbacks.
Public access: Provides an HTTPS experience reviewers can use without installing tools or relying on your laptop.
Reproducible deployment: render.yaml documents the build, startup, health check, and environment configuration.
Clear provider roles: Render hosts the application and Whisper; Cloudflare Workers AI runs Llama inference.
GitHub Copilot : I used it for coding

Sloth Archivist: Clean Your Camera Roll and Journal As You Sleep

S.Busienei — Mon, 26 Oct 2026 05:58:56 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

My camera roll fills up faster than I clean it: blurry pocket shots, five copies of the same moment, screenshots of codes I needed for thirty seconds. I also keep meaning to start a journal. I have done neither.

Sloth Archivist does both while I sleep. It runs overnight on my laptop with an open-weight model and gives me two things in the morning:

A review folder with junk moved into reason buckets (duplicate, blurry, dark, screenshot…).
A short daily journal written from the photos worth keeping, where every sentence is checked against what the model actually saw.

It never deletes anything. Every move is logged in manifest.jsonl, and python -m sloth undo --run <id> puts every file back. Only I can empty the review folder, and even then it goes to the Recycle Bin.

It's for anyone with a camera roll they've given up on and a journal they never started.

Demo

👉 See the sample report: a real run over an 18-photo test set, with the summary, the review grid and the journal entry.

The sample set is deliberately synthetic, so no personal photos appear anywhere in this post or the repo. Each image targets one failure mode:

Near-duplicates (perceptual hash should keep only the sharper one):

Quality failures (blurry, underexposed, overexposed, caught by rules with no AI):

The hard boundary for Gemma: a throwaway screenshot (junk) versus a document someone may need later (keep):

Code

SBusienei / sloth-archivist

Sloth Archivist

See an example

Sloth Archivist is an offline-first Python CLI that triages photo folders and writes day-by-day journal entries from the photos worth keeping. It uses deterministic image quality rules first, then local Gemma inference through Ollama for the remaining photos, and keeps a full audit trail of every decision.

Why this project exists

Large camera rolls usually contain a small number of meaningful photos mixed with duplicates, blurry shots, over/under-exposed images, and throwaway screenshots. Manual cleanup is slow and hard to maintain consistently.

Sloth Archivist automates this workflow with three priorities:

Safety first: nothing is deleted during triage; junk is moved to a review folder and can be restored with one command.
Local inference: Gemma runs through Ollama on your machine.
Traceability: every decision is logged with stage, reason, model, prompt version, and timing.

Core workflow

sloth run executes this pipeline:

Ingest (ingest.py…

View on GitHub

How I Built It

phone camera -> laptop inbox (overnight)
  -> EXIF date + GPS (fallback: file mtime, Google Takeout sidecar JSON)
  -> offline place names (reverse_geocoder, no API key)
  -> rule filters first, no AI:
       - perceptual-hash duplicates (keep the sharpest)
       - blur score (variance of the Laplacian)
       - dark / overexposed thresholds
  -> Gemma 3 4B via Ollama: caption + keep / junk / needs_review as JSON
  -> junk moved to _sloth_review/<reason>/ (manifest logged, undoable)
  -> kept photos grouped by day and place
  -> journal draft -> fact-check -> retry once -> template fallback
  -> static report.html with thumbnails

Everything runs on a 16GB Windows laptop with no CUDA GPU, using local Python and Ollama. The model is gemma3:4b, images are resized to 768px, and decoding uses temperature: 0, so the same photos always give the same output. That made it possible to compare runs fairly.

Cheap filters first

Most junk doesn't need a language model. In the 18-photo sample run, rules classified 9 photos as junk before Gemma saw anything, so only 9 needed a model call. On a CPU-only laptop, halving model calls is the difference between "done before morning" and "still running at breakfast." It also makes debugging easier: a rule decision comes with a number (blur score, hash distance, brightness) you can inspect.

Gemma decides the rest

Each surviving photo goes to Gemma through ollama.chat with:

options={"temperature": 0}
format=<Pydantic JSON schema> (caption, verdict, reason, confidence)

Validation is strict. Malformed output is retried up to twice, then the photo is marked needs_review. When unsure, the answer is needs_review, never junk. Missing a junk photo costs nothing; moving a precious one is the real failure. Every decision is logged in decisions.jsonl with the model name, prompt version and seconds taken.

The journal is fact-checked

A small model writing a diary will happily invent a sunset or a friend who wasn't there. So for each day, the journal prompt receives only three kinds of facts: times, place names and Gemma's own captions. Then factcheck.py checks the draft:

text is lowercased and crudely stemmed;
every content word must appear in the facts or a small allow-list (common verbs, feelings, times of day);
every number must appear in the facts.

If a draft fails, Gemma gets one retry with the rejected words named, for example:

The facts do not mention: bicycles, 3

If the retry also fails, the day gets a plain template entry built only from the facts. Every line in the journal is either checked or plain data.

In the sample run checked into the repo, the day ended on the template path: the model's drafts didn't pass, and the fallback did exactly what it was designed to do. I'd rather publish a plain true sentence than a lively invented one.

Evaluation on hand-labeled photos

I hand-labeled 10 sample photos in eval/labels.csv and ran python -m sloth eval:

Version	What changed	Junk precision	Junk recall	Notes
v1	Baseline review prompt + rule front-pass	0.857	1.000	Rules handled 6 photos; Gemma handled 4

Recall of 1.0 means every photo I labeled junk was caught. Precision of 0.857 means one photo it moved was one I'd have kept. Reading that failure taught me more than the number: misses weren't random model drift but policy boundaries, such as whether a screenshot is throwaway or a record someone may need later. Clearer boundaries in the prompt helped more than adding post-processing. Because nothing is ever deleted, that one wrong move costs a single undo.

What the check can't see

From my hand review in eval/REVIEW.md: 0 right, 1 clumsy, 0 wrong. The fact-check verifies support, not writing quality: a sentence can use only true words and still read flat or awkward. The check narrows what can go wrong from "anything the model can imagine" to "true words put together clumsily."

One surprise

Local Ollama responsiveness was unreliable in automated runs. To keep CI and dry-run checks deterministic, I added a fake/heuristic Gemma client for non-production validation, while full runs always use the real model. Tests never need Ollama, so they run anywhere.

Built with GitHub Copilot

I built this in small tasks with Copilot's coding agent, guided by a .github/copilot-instructions.md that encoded the project's hard rules: never delete, undo first, Gemma only, temperature: 0, tests must not need Ollama. Copilot was fast at scaffolding modules and tests; I still had to correct integration details, especially run orchestration, logging and fallback behavior. A GitHub Action runs the tests and a dry-run summary on every push and pull request.

Why Does Open Innovation Matter?

My photos never leave the laptop. A camera roll holds faces, IDs, bank screenshots, and home addresses hidden in GPS tags. With an open-weight model running locally, none of that is uploaded anywhere. Place names come from an offline dataset.

It costs nothing to run every night. A nightly job over a camera roll through a paid vision API is a recurring bill. Here it's electricity.

It works offline. On a trip with no signal, the journal still gets written.

I could see and steer every step. Same model, same prompt, temperature 0, same output, so every change could be measured on the same photos. Retries are free, so being strict is free.

Where a closed model would be better: speed and polish. A frontier vision model would caption faster than my laptop's CPU and write livelier entries. It would still need the same fact-check, and it would need my whole camera roll.

My Agent Session

I built this project with iterative Copilot coding sessions and task-by-task validation.

The architecture and data flow are documented module by module in docs/python-ml-walkthrough.html: each Python module, the inference path, retries, and the run artifacts (manifest.jsonl, decisions.jsonl, latest_run.json).

The Lazy Payoff

From the latest sample run:

18 photos scanned
9 moved by rules, 4 moved by Gemma
5 kept
1 journal entry written
0 files deleted, 100% restorable with undo

That's 13 of 18 photos I never had to look at individually, and a written trace of the day I'd otherwise never have written. In practice, I review a much smaller folder and still keep a diary, without doing either job myself.

Prize Categories

Best Use of Gemma: Gemma 3 4B handles captioning, keep/junk/needs_review decisions and journal drafting locally through Ollama, with strict JSON schema validation, retries, and a fact-check on every journal sentence.
Best Use of GitHub Copilot: built module by module with Copilot's coding agent from repository instructions that enforce non-destructive behavior; a GitHub Action runs the tests and a dry-run summary on every push.

Excel: Relevant Or Outdated

S.Busienei — Thu, 02 Jul 2026 16:46:45 +0000

Excel has been there for 40 years, and it continues to stand the test of time. The real question is, Is it worth learning in the Age of AI? I decided to explore what it is by building a mini “M-Pesa Wrapped” (Spotify Wrapped but for my money). Turns out a few formulas could quickly tell me more about my spending habits than a full month of “just checking my balance.”

Spotify Wrapped Ruined Boring Statements For Me

Every December, Spotify tells me my top artist, my “listening age,” and how many minutes I spent listening to the same three songs on repeat. It’s fun. It’s personal. It makes numbers feel like a story.
Then I open my M-Pesa statement, a lot of transactions without any narrative. Every once in a while, after a fun adventure of ‘kurudishia mwili pole’ I always wonder: where did my money go?

What Excel Actually Is (For Anyone Who’s Never Opened It)

It’s a giant table, like a notebook page made entirely of boxes. Each box is called a cell. You can type a number into a cell, a word, a date or a little instruction that tells Excel to do math for you.
That last part is the magic trick. Say you type =B2-C2 into a cell. Excel doesn't just do random calculations, it remembers what’s in that cell and works with it. So if you go back and change what's in box B2, that cell updates itself instantly. No retyping, no redoing the math by hand. Everything connected to it just...updates. That's really the entire reason spreadsheets took over from paper ledgers back in the 1980s, one change and the whole sheet recalculates itself like magic.

Okay, But Is It Outdated?

Short answer: no, but it’s had to evolve.

The honest truth is that Excel isn’t competing to be the most powerful tool anymore, it’s competing to be the most available one. Python and R can do more, but they need setup, syntax, and patience. Power BI and Tableau look slicker, but they require time to learn. Excel is already on your laptop (probably thanks to some cyber in some corner) and you have probably played around with it before.

There’s also a quieter reason it survives: almost every other tool still exports to it. Bank statements, government portals, POS system still hand reports as spreadsheets. Even brand-new AI-powered analytics tools are being built as Excel add-ins rather than Excel replacements, which says something about who actually has the market share.

So not outdated, just no longer lonely at the top.

Three Real-World Uses

1. Financial reporting
Using my M-Pesa statement, I turned a month of scattered transactions into a single monthly summary, including my highest-spend days and what ate my money most(hint: me). This is exactly what accounting software like QuickBooks and Zoho Books do for a business, just automated and prettier. They pull every transaction, group it, and generate a monthly report. Underneath the polish, it’s the same Excel logic: SUMIF, group by category, find total in each group, done! Even the mpesa monthly statement above is built this way.

2. Spotting patterns
Once the data was summarized, one category quietly ate more of my money than anything else. That’s the exact move retailers make when deciding where to cut costs or invest more. Platforms like Jumia’s seller dashboards run this same logic behind the scenes to flag best and worst performing products, just with a live database instead of a spreadsheet.

3. Trend analysis over time
Grouping transactions by day showed me exactly which days I spend the most (weekends are a disaster for my wallet). This is the same logic behind some business decisions you’ve probably seen, e.g. “Terrific Tuesday” probably exists because someone analysed how low Tuesday Pizza sales were and decided to boost it with a deal.

Getting started is very easy, here are very simple functions that helped derive the story from the data:

(Bonus function: conditional formatting to automatically highlight your single biggest transaction of the month in red)

Weekend Projects If You Want to Try This Yourself

Here are some ideas on what you can get started on:

M-Pesa/bank statement Wrapped — the one from this article. Great starter project, real data, immediate payoff. There is a very nice step-by-step guide to setup the Mpesa Analysis Project here
A small-business or side-hustle tracker: if you sell anything on the side, track orders, costs, and profit margin the same way a big business would.
A job-application tracker: dates applied, status, follow-up reminders using conditional formatting to flag anything gone quiet for 2+ weeks.

My Reflection
To track my spending, a pivot table took about three minutes to show me something a full month of casually checking my balance never did, without setting up extra tools. That’s the real case for Excel in 2026, not that it’s the most advanced tool in the room, but that it turns “I think” into “I can see” almost immediately.

Relevant or outdated? After this experiment, I think it is still relevant

Python For Everyone: Mastering Python The Right Way

S.Busienei — Fri, 04 Mar 2022 15:13:27 +0000

I have recently been reading 'Atomic Habits' by James Clear. In the book, James has a captivating style of breaking down the formation of Habits. One particular example is how if we constantly improve our habits by 0.1% daily, in a year we will be 37 times better at the skill.
That is just by merely improving 0.1%, what about 1% 10% 50%; the possibilities are limitless.
This very similar to Mastery of anything and in our case, Mastery of Python. We can only get better if we aim to practice and improve daily even if it's just by 0.1% #NoZeroDays. In this article, I will recommend a few resources that may be helpful in achieving this mastery.

The Zen Of Python

We can not truly become masters at Python without viewing the Zen of Python. Type import this on your command line and run it.

>>> import this
'''
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
'''

This Zen will give the basic guiding rules for learning and even mastering Python.
No matter what Python Path you intend to pursue, mastery of the basic concepts will be very vital to help you build a strong foundation in Python and allow you to code The Pythonic Way.

Dear Python Sensei, Here are a few tips to kickstart your journey:

Set Your Goals

Setting goals is effective in helping us accomplish a lot. Before beginning your journey, determine what you hope to accomplish. Are you working towards Web Development, focus on learning Frameworks eg. Django. If it is in Data Analysis mastery of libraries such as Pandas, numpy etc. will be instrumental.
Recursively breaking down your goals to Monthly, weekly chunks is also very important. In something as basic as a coding session, write down what you hope to achieve within the coding session. A SMART goal is Specific, Measurable, Achievable, Realistic and within a TimeFrame eg. make a number guessing game, with concepts learnt, within my first 4 weeks.

Resources For Setting Goals:

Pen and Paper - Write down your goals
Pomodoro Timers: Time-blocking and Focus Mode helps block out chunks of time interspersed with rest to focus on the matter at hand, that is coding.
Version control Systems eg. Github, Bitbucket, Gitbucket help in version control of your code and generally storage of your code. It can also serve as a visual reminder of the progress you make eg. on Github there is a monitoring system that shows how many days you are active on the platform.

Finding A Community

Sticking to a habit is not solely based on 'Motivation' alone; some days you just don't feel like it. A community/accountability partner will be paramount in keeping you in check and challenging you to be better.
Such communities can be on social media platforms eg. r/python and r/learnpython, these platforms have a lot of people looking to learn python like you.
Tags like #100DaysOfCode on Twitter and other platforms allow different programmers to share their progress journeys during the sacred 100 days of code.

Stick To A Few Beneficial Resources

The internet has been very revolutionary in every sense. In terms of learning it has granted us access to a ton of resources at our fingertips. I can literally just type 'Harvard Python Course' and get access to the CS50 course on edx.
All these resources can suck as into a 'Learning rabbit hole'. Jumping from one exciting resource to another. My advice; Set and focus on your goal, identify a suitable course that helps you in the pursuit of your goal. Break the course down to manageable chunks and follow through with it.

Pro Tip: Select a well structured course like those on Free Code Camp. A well-structured course saves on time and resources otherwise wasted scouring the internet.

You don't have to finish the course, just stick with it until you've achieved your goal.
Take Notes: > I hear and I forget. I see and I remember. I do and I understand. During a lesson write down short keywords. After the lesson try and recall what you learnt during lesson. If you are not a fan of writing down on paper(which I strongly root for), use Notion, a very easy, convenient and resourceful note-taking application.

The Last and Ultimate Python Secret!!

CODE!!

Even if you follow tutorials and code as the instructor goes through the concept, you still have to put in the hours. Start with as little time as you like and work your way up. Constant Coding and dedication is the biggest difference between a Beginner and Master.
I appreciate that you are still reading this article, but after quickly liking this article, please click on some of the resources I have shared- the resources are all free to use and will be of great help to you.
Don't be scared of bugs or being stuck on a problem. The world has millions of developers, your problem isn't as bad as it seems just google it. Platforms like Stack Overflow exist for this sole purpose. In this Journey, Google Is Your Best Friend

Day 1 of Coding
Creating a Hello World Program

Download Python
Open your command line. Use the (Win + R) shortcut. Write cmd and press enter.
On the command line, switch to the python terminal by typing py C:\Users\user>py
On the Python terminal, print Hello World

>>> print("Hello World!!")
Hello World!!

You are now ready for the greatness.

Install your Favourite Text Editor. Here are a few examples: Visual Studio, Atom, SublimeText.

Concepts To Learn at Every Stage from Basic to Advanced

Basic
Most of them are in My First article ever

Intermediate

Comprehensions
Data Structures
Lambda Functions
Files I/0
Inheritance and OOP
Dunder Methods

Advanced
1.Frameworks(Django, Flask, etc.)
2.Decorators and Generators
3.Multithreading and Processing
4.Testing
5.Complex Libraries

Looking Forward To Hearing from You. If you are a more experienced programmer, please leave some of your tips and tricks with us on the comment section.
Looking Forward to hearing Your Thoughts.

Introduction to Data Structures

S.Busienei — Sun, 20 Feb 2022 19:58:35 +0000

A Data Structure is a special format of organizing, processing, retrieving and storing data. They may not be discussed mainly but they are very vital in our systems today.
Today we will focus on the basic data structures that are our unsung heroes of our systems today. Here is a link to an article that has more general information on What are Data Structures

1. Lists

Lists contain multiple values in an ordered sequence. Values inside the lists are called items and are comma-separated.. - - The lists are zero-indexed hence the first value in a list is usually at index O. Indices are used for item retrieval.
When a list is created all the elements are stored contiguously in memory(the memory allocated for a list is within the same location)

>>> pets = ["cats","dogs","rabbit","parrot"]
>>> pets[0]
'cats'
>>> pets[-1]
'parrot'
>>> pets[1:3]
['dogs', 'rabbit']
>>> pets[:3]
['cats', 'dogs', 'rabbit']
>>> pets[2:]
['rabbit', 'parrot']

List Methods

Append - this method adds an item to the end of the list
Insert - inserts an item at a particular index
Delete - deletes an item at a particular index
Remove - deletes the item passed

If there are 2 or more instances of the same item, the first instance is usually deleted
Sorting - ordering of items in a list
Lists are sorted according in ascending order
Alphabetical lists are sorted in "ASCIIbetical Order", that is uppercase letters then lowercase letters later
Lists with multiple data types cannot be sorted
The reverse() method orders the items in the list in descending order

>>> pets.append("monkey")
>>> pets
['cats', 'dogs', 'rabbit', 'parrot', 'monkey']
>>> pets.insert(1,"hamster")
>>> pets
['cats', 'hamster', 'dogs', 'rabbit', 'parrot', 'monkey']

>>> del pets[0]
>>> pets
['hamster', 'dogs', 'rabbit', 'parrot', 'monkey']
>>> pets.remove("dogs")
>>> pets
['hamster', 'rabbit', 'parrot', 'monkey']

>>> pets.sort()
>>> pets
['hamster', 'monkey', 'parrot', 'rabbit']
>>> pets.reverse()
>>> pets
['rabbit', 'parrot', 'monkey', 'hamster']

2.Tuples

They are very similar to lists but are immutable(hence we cannot add, remove or change them in any way). This can be advantageous as python is able to run them faster than lists.
They are formed using ( )
I higlighted, key differences between lists and tuples in my previous blog post.

pets = ('rabbit', 'parrot', 'monkey', 'hamster')
>>> pets[0]
'rabbit'

>>> pets.add('cats')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'add'

>>> del pets[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

#it can also be defined with a comma after the last item to explicitly declare them as tuples
>>> pets = ('rabbit', 'parrot', 'monkey', 'hamster',)
>>> type(pets)
<class 'tuple'>

3. Dictionaries

They are unordered data structures that store items in (Key:Value) pairs. They are defined using { } or using the **dict() **constructor.

>>> pets_colour = {'cat':'white','horse':'dark','dog':'golden'}
>>> pets_colour(cat)
>>> myfriends_age = {'Chao':21,'Too':19,'Rono':40,'Juma':32}
>>> myfriends_age
{'Chao': 21, 'Too': 19, 'Rono': 40, 'Juma': 32}

Dictionary Methods

These methods can be used in for loops to retrieve the specified elements.
dictionaryName.keys() - is used to retrieve the keys used in the dictionary
dictionaryName.values() - is used to retrieve the values used in the dictionary
dictionaryName.items() - is used to retrieve both the values and keys in the dictionary

myfriends_age = {'Chao':21,'Too':19,'Rono':40,'Juma':32}

>>> for age in myfriends_age.values():
...     print(age)
...
21
19
40
32


>>> for name in myfriends_age.keys():
...     print (name)
...
Chao
Too
Rono
Juma


>>> for name,age in myfriends_age.items():
...     print(f"{name} is {age} years old")
...
Chao is 21 years old
Too is 19 years old
Rono is 40 years old
Juma is 32 years old

4. Sets

They are unordered(they can be saved and retrieved in whatever order and cannot be referenced by an id or key) collection of items, unchangeable and only allow unique items(hence no repetition of values).
To create a new set, we use the set() constructor, the curly braces { } are too ambiguous and may create a dictionary instead

#creating a set using curly braces { }
odd_numbers = {1, 3, 5, 7, 9}
#check set membership
9 in odd_numbers
#results in True

#creating a set using a set constructor
>>> odd_numbers = set((1,3,5,7,9))
>>> odd_numbers
{1, 3, 5, 7, 9}

#inserting elements into the set
>>> odd_numbers.add(11)
>>> odd_numbers  
{1, 3, 5, 7, 9, 11}      

#adding a duplicate value does not change the set
odd_numbers.add(3)
odd_numbers
 {1, 3, 5, 7, 9, 11}    

#length of the set
len(odd_numbers)
6

#Removing an item
>>> odd_numbers.remove(5)
>>> odd_numbers
{1, 3, 7, 9}
>>> odd_numbers.discard(7)
>>> odd_numbers
{1, 3, 9}
>>> odd_numbers.remove(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 5
>>> odd_numbers.discard(5)
>>> odd_numbers
{1, 3, 7, 9}

#delete entire set
del odd_numbers

Frozen Sets are immutable versions of sets. We can not insert or delete from them but rather query them.

>>> odd_numbers = frozenset({1, 3, 5, 7, 9, 11}) 
>>> odd_numbers.add(13)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

These frozensets are hashable and can be used as dictionary keys.

>>> odd_numbers ={ frozenset({1, 3, 5, 7, 9, 11}):"These are Odd Numbers"}
>>> odd_numbers[frozenset({1, 3, 5, 7, 9, 11})]
'These are Odd Numbers'

5. Queues

Queues function just like real-life queues observing the FIFO(First In First Out) principle. Items enqueued into the queue first are usually *dequeued * first.
They are implemented using either lists(they can be quite slow) or inbuilt Queue module(especially used with parallel programming due to the resource locks) or the deque module from collections(for general use)

#Using Lists
>>> my_queue = []
>>> my_queue.append(1)
>>> my_queue.append(2)
>>> my_queue.append(3)
>>> my_queue
[1, 2, 3]
>>> my_queue.pop(0)#pop at index 0
1
>>> my_queue
[2, 3]

#using the queue module
>>> from queue import Queue  
>>> my_queue = Queue()
# We use .put() to insert value and .get() to pop the first one.
>>> my_queue = Queue()
>>> my_queue.put(1)
>>> my_queue.put(2)
>>> my_queue.put(3)
>>> print(list(my_queue.queue))
[1, 2, 3]
>>> my_queue.get()
1
>>> print(list(my_queue.queue))
[2, 3]

#Using collections.deque
>>> from collections import deque
>>> my_queue = deque()
>>> my_queue.append("Me")
>>> my_queue.append("Myself")
>>> my_queue.append("I")
>>> my_queue
deque(['Me', 'Myself', 'I'])
>>> my_queue.popleft()
'Me'
>>> my_queue
deque(['Myself', 'I'])

6. Stacks

They are data structures that implement the LIFO(Last In First Out) principle of accessing, inserting or deleting items. Items are *push*ed (inserted into the stack) and *pop*ped(removed from the stack) at the top of the stack (hence does not allow random retrieval like arrays and lists)
They can be implemented using Lists or deque module from collections

>>> my_stack = []
>>> my_stack.append("I")
>>> my_stack.append("love")
>>> my_stack.append("Python")
>>> my_stack
['I', 'love', 'Python']
>>> my_stack.pop()
'Python'
>>> my_stack
['I', 'love']


#using deque
>>> from collections import deque
>>> my_stack = deque()
>>> my_stack.append("I")
>>> my_stack.append("love")
>>> my_stack.append("Python")
>>> my_stack
deque(['I', 'love', 'Python'])
>>> my_stack.pop()
'Python'

7. Linked Lists

** Whew! This is a whole topic but I'll skim over the basics here.

Linked lists is a data structure that contains a chain of nodes in different parts of memory that are linked to each other.
There are different types of linked lists(singly and doubly). Singly linked lists can be traversed in only one direction - left to right while doubly linked lists can be traversed left to right and right to left.
Each node contains its own data value and a memory address that references to the memory location of the next node.

Creating a Node - create a node class with the data and next variables.

>>> class Node:
...   # constructor
...   def __init__(self, data, next=None):
...     self.data = data
...     self.next = next
...
>>> # Create a single node
>>> first = Node(3)
>>> print(first.data)
3

Create a Linked List

The first element in the Linked List is the head of the list.

class LinkedList():
    def __init__(self):
        self.head = None

Linking nodes within the list

new_node = Node(data)
head.next = new_node

There is a lot to cover within Linked Lists, I won't cover majority of it here since this post is getting too long.

Data structures are very vital and if you want to work in FAANG companies, mastery of this structures will come in handy.
This is just the tip of the iceberg. Advanced structures like graphs in Dijkstra's Algorithm are used in Google Maps for distance estimations.
A very important part of data structures is their Memory and Time Complexities. These complexities dictate the advantage of one structure over another for different use cases.

In the meantime, let me know in the comments section where the data structures above can be fundamental.

Introduction to Modern Python

S.Busienei — Mon, 14 Feb 2022 10:35:29 +0000

Introduction

You most probably know why and are now scouring the internet for Zen advice on how to go about the language. Well, Same here.
We will discuss the absolute basics and I will link some resources(and cheatsheets) that will be be helpful in learning the Language. I will discuss Primitive Data Types, Math Operands and inbuilt data Structures.

Data Types

1. Strings

Strings are usually alphanumeric characters enclosed in "" or ' '. They can be manipulated in a variety of ways through: Concatenation, Replication, Slicing and a variety of other methods(convert to upper, lower and replacing or iterating through the characters)

x = 'Python'
y = 'Developer'
#string Concatenation
x + y # returns PythonDeveloper
#string Replication
x * 3 # returns PythonPythonPython

len(x) # length of string -- in this case 6
x[0] #returns first letter - p
x[-1]#returns the last letter - n
x[0:3]#returns characters from within the specified range -- pyt

name = f 'I am a {x }{y}' # returns I am a python developer 
x.upper()    #converts to uppercase PYTHON
x.lower()    #converts to uppercase python
x.title()    #converts to titlecase Python
x.strip()    #removes first and last character and returns the string
x.find(“p”)  #finds index of passed character within the string
x.replace(“a”, “b”) #replaces the first passed character with the second one
“a” in x      #find character within the string

2. Numeric - These values can wither be integers, floats or complex numbers
3. Boolean - These is either True or False. It can be used mainly for comparison operations and conditional statements.
4. Special- None

a = 1       # integer
b = 1.1     # float
c = 1 + 2j  # complex number (a + bi)
d = “a”     # string
e = True    # boolean (True / False)
b = ()      #an empty list evaluates to None

Math Operands

Mathematical Operands enable the performance of mathematical operations within our program.
Just like ordinary mathematics, the operands appear in order of precedence as listed below: (*) ()(/)(//)(%) (+)(-) in that order.

2 ** 3     #returns the exponent = 8
2 * 3      # returns 6
12 / 2     #returns 4
24 // 5    #returns 4
24 % 5     #returns the remainder that is 4
28 + 3     #returns 31
28 - 3     #returns 25

Data Structures

1. Lists

Lists contain a collection of items. They are very similar to arrays, however the only difference is that list can store different data type elements while arrays only store elements of a similar data type
They are defined using [] or list() constructor

list1 = ['potatoes',59, 8.5, 'sugar']
list2 = list(('potatoes',59, 8.5, 'sugar'))

2. Tuples

They are an immutable(hence they cannot be changed or modified once declared) and unordered data structures that store a collection of items. They are defined using ()

tuple1 = ('potatoes',59, 8.5, 'sugar')
len(tuple1) # returns 4 that is the number of items in the tuple
del tuple1 # to delete the entire tuple

Difference Between Tuples and Lists

Lists are defined using [] while tuples are defined using ()
Lists are mutable(can be changed and modified) while tuples are immutable
Tuples are more memory efficient and execute faster than lists.

3. Dictionaries

Dictionaries are data structures that store items as key:value pairs. They are defined using {}
Using the keys and values different items within the dictionary can be accessed

my_dict = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
my_dict[0] # returns the first item in the dictionary

4. Sets

Sets are unordered data structures that store unique elements_(No duplicates Allowed!!)_. They are defined using {}

my_set = {5, 4, 6, 7}

VARIABLES AND CONSTANTS
Variables are place-holders that serve to reference items. CONSTANTS are values that once declared remain the same and cannot be changed within the scope of the program.
Rules that Governs naming a variable.

It can be only one word(No spaces between the words please)
It can use only letters, numbers, and the underscore (_) character.
It can’t start with a number. CONSTANTS are usually declared in uppercase letters.

Comments
Python comments are preceded with a #. For multiple lines, you can learn a shorthand command for commenting, eg. Ctrl + K + C in VSCode.

#this is a CONSTANT
CONSTANT = 5
#this are variables
myName = 'Developer X'
my_age = 15

Beginner Friendly CheatSheets

Programming with Mosh : https://programmingwithmosh.com/python/python-3-cheat-sheet/
Official Python Cheatsheet : https://www.pythoncheatsheet.org/