DEV Community: Michellebuchiokonicha

Machine Learning

Michellebuchiokonicha — Thu, 08 Oct 2026 07:15:54 +0000

Michellebuchiokonicha

Oct 8

I Turned 149k Messy Images into an Offline Recognition System

#ai #machinelearning #programming #data

13 min read

I Turned 149k Messy Images into an Offline Recognition System

Michellebuchiokonicha — Thu, 08 Oct 2026 06:31:39 +0000

Training an on-device YOLO26n food detection model from scratch across multi-source datasets

I set out to build a food recognition system that could look at a photo, tell you what each item is, count how many there are, flag anything that looks spoiled or rotten, and pick out the things that are not food at all. The twist is that it had to do all of that on a phone or an iPad with no internet connection, which meant there was no cloud to lean on and no API to call when the model got confused.

You would think the hard part of a project like this is the model, but for me it was the data.

I had about 149k images collected from different sources, and once I set aside one large dataset that had no bounding boxes, I was left with 49,158 images from 11 datasets to work with. Every one of them had its own way of naming things, its own idea of what a good photo looks like, and plenty of the same pictures turning up again and again. So before I trained anything, my first real job was deciding what to throw away.

I wrote this as I went, following the pipeline in the order I ran it in Google Colab, so you will see the problems I ran into and how I fixed them. Some of the mistakes were mine, and I have left them in on purpose, because that is where most of what I learned came from.

If you are about to train a model on data from more than one place, I hope this saves you a few of the wrong turns I took.

How fast the data shrank

The part that surprised me most was how much smaller the dataset got at every single stage, so I have laid it out in a table before we get into the details.

Stage	Images
Original collection	about 149k
After removing a large dataset with no bounding boxes	49,158
After blur, brightness and duplicate cleaning	31,589
Clean images that actually had usable labels	24,306
Final split	20,660 train and 3,646 validation

That means I did not train on 49k images at all, I trained on about 20k, and every one of those drops had a reason that I will walk through as we go.

Checking the GPU first

This job needs a GPU, because a full run means a lot of epochs over a big dataset after several rounds of cleaning, and on a CPU that would take days where a Colab T4 gets it done in hours, so the first thing I do in any session is check what I have been given.

import torch

print('GPU available:', torch.cuda.is_available())
if torch.cuda.is_available():
    print('GPU name:', torch.cuda.get_device_name(0))
    print('VRAM:', round(torch.cuda.get_device_properties(0).total_memory / 1e9, 1), 'GB')

Mine came back as a Tesla T4 with 15.6 GB of VRAM, and if yours says no GPU is available you will need to either pay for one or find a free platform that offers it.

Configuring the run

A handful of variables control the whole run, and I like setting them all in one place at the top so I never have to hunt for them later.

RUN_MODE = 'train'          # 'baseline_only' or 'train'
SAMPLE_SIZE = None          # None uses everything, 5000 gives a quick test run
BLUR_THRESHOLD = 50
HASH_DISTANCE = 5

I planned the work in three stages, starting with a baseline run to see what the off-the-shelf model knows, then a small 5k training run to prove the whole pipeline works, and finally the full run once the pilot looked sensible. RUN_MODE decides whether the work stops at the baseline or training goes ahead, and the later cells simply check that one variable with an if/else.

The pilot saved me a lot of pain, because the bugs I found on the small run would have cost me hours if I had only discovered them on the big one.

Getting the data into Colab

I compressed the annotated data into a zip and stored it on Google Drive, and since reading straight from Drive is slow, I copy the zip onto Colab's local disk and extract it there, which is where two things went wrong for me.

The first was a partial extraction, where after a disconnect I ended up with a half-unzipped folder that looked perfectly fine but was missing files, and I only caught it because I counted the images and compared the total with the zip, so now I delete the folder, unzip again and check that the count is 49,158 before moving on.

The second was an extra nesting level, because the zip extracted to data/data/datasets and a hardcoded path simply fails, so I use a glob to find the datasets folder wherever it happens to land.

matches = glob.glob(os.path.join(EXTRACT_DIR, '**/datasets'), recursive=True)
datasets_dir = matches[0]

Installing and importing

!pip install -q ultralytics imagehash tqdm pyyaml

import os, glob, subprocess, shutil, random, json
from collections import Counter

import cv2
import imagehash
import numpy as np
import torch
import yaml
from PIL import Image
from tqdm import tqdm
from ultralytics import YOLO
from google.colab import drive

Ultralytics handles training, inference and evaluation, imagehash finds near duplicates, tqdm gives you progress bars, and PyYAML reads and writes the dataset config files. Ultralytics runs on PyTorch, which is why torch is imported for the GPU check, while OpenCV and PIL do the image work.

Discovering the classes

Next I read every data.yaml and printed the classes from each dataset, which looks like a boring step but is the one that shows you just how messy your data really is.

What I found is probably what you will find too, which is that the same thing gets named in many different ways. One dataset called something tomato, another vine-tomato and a third beef-tomato, apples came as granny-smith, pink-lady and royal-gala, and bell peppers showed up by colour and sometimes as bell-pepper and sometimes as bell_pepper. On top of that there was a long tail of overly specific labels for packaged products with brand names and sizes baked in, and if you leave all of that alone, every variant becomes its own class and the total balloons far past the number of distinct things you actually care about.

The bigger problem was the numbering, because in one dataset egg was class 6 and in another it was class 5, and if you train on both without fixing that, the model is told that one object is two different things and that two different things are the same.

Then there was one more thing that caught me out, because when I globbed for label files I also picked up the README files, and a "label" I opened turned out to contain the text of an export note instead of box coordinates, so I started filtering out anything with README in the name and checked my counts by tallying annotations per class in a dataset I knew well.

Building the unified class list and remapping labels

This is the step that decides whether your model ends up good or bad, so it deserves the most care, and I broke it into three parts.

First I merge the aliases, using a dictionary that maps every variant to one canonical name. I only merged things that are really the same object at the level of detail the task needs, and I kept spoiled and fresh versions as separate classes.

MERGE_ALIASES = {
    'granny-smith': 'apple', 'pink-lady': 'apple', 'royal-gala': 'apple',
    'vine-tomato': 'tomato', 'beef-tomato': 'tomato',
    'bell-pepper': 'bell_pepper', 'capsicum': 'bell_pepper',
    # ...many more
}

How hard you merge depends on what your model is for, so if you need to tell two varieties apart, keep them separate.

Then I build the global list by resolving every name through the aliases and sorting the result alphabetically, so the order stays stable between runs.

GLOBAL_CLASSES = sorted(all_class_names)

That gave me 94 classes, numbered 0 through 93.

Finally I rewrite every label file, because the first number on each line of a YOLO label file is the class ID and I needed every class to have the same ID in every dataset. In total 48,763 label files were remapped, and only 139 annotations were dropped because they mapped to nothing useful.

Cleaning the images

Blurry, badly lit and duplicated images teach a model bad habits and waste GPU time, so I filtered on four things, starting with blur.

Blur

The blur check converts the image to grayscale and runs a Laplacian filter, which responds to edges, so sharp images have strong edges and a high variance, while blurry ones have a low variance and get rejected if they fall below the threshold.

def is_blurry(img):
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    return cv2.Laplacian(gray, cv2.CV_64F).var() < BLUR_THRESHOLD

The usual starting threshold is 100, but my pilot run is the reason I changed it, because at 100 the filter threw away 14,732 images, about 30% of everything, and only 44.3% of the data survived cleaning. Food photos are often close-ups with soft textures and shallow depth of field, which score low even when they are perfectly good, so I dropped the threshold to 50, which cut the blurry rejections to 6,326 and lifted overall retention to 64.3%.

Brightness

def is_bad_brightness(img):
    m = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).mean()
    return m < 30 or m > 225

An average below 30 means the picture is too dark to see anything and above 225 means it is washed out, and that check removed 929 images.

Duplicates

The same images appear across several scraped datasets, so duplicates were a big deal, and a perceptual hash is a good way to catch them because it fingerprints what an image looks like and near-identical images get near-identical hashes, so if a new image is within a hash distance of 5 of anything already seen, I skip it.

h = imagehash.phash(Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)))
if any(h - sh <= HASH_DISTANCE for sh in seen_hashes):
    dupes += 1
    continue
seen_hashes.append(h)

This dropped 10,314 images, and it is also the slow part, since every new image is compared against every hash kept so far, which means the loop gets slower as it goes and the whole cleaning pass took about 42 minutes for 49,158 images.

Letterboxing

YOLO expects square input and squashing a photo into a square distorts the shapes of the objects, so letterboxing scales the image to fit inside 640 by 640 and pads the rest with grey (pixel value 114), and the label coordinates have to be recalculated to match, which is very easy to forget.

scale = TARGET_SIZE / max(h, w)
nw, nh = int(w * scale), int(h * scale)
canvas = np.full((TARGET_SIZE, TARGET_SIZE, 3), 114, dtype=np.uint8)

I letterboxed the images to 640 by 640 myself and saved them to disk, even though Ultralytics can do it on the fly with imgsz=640, and the reason was speed. Many of my source images were large camera captures, and decoding big JPEGs again on every epoch was keeping the Colab CPUs busy while the T4 waited for data, so resizing once up front made the files smaller and the extraction quicker, and it left me with the exact offset and scaling logic I needed later to prepare camera frames for the ONNX model on the device.

Where the labels went missing

This one surprised me, because of the 31,589 clean images only 24,306 had a usable label file, and in the pilot it was much worse, with just 7,758 of 21,780. Some images never had annotations in their original dataset and some lost all of theirs during class remapping, but either way an image without labels is no use for detection training, so they were dropped.

Splitting into train and validation

I split the data 85 to 15, which gave 20,660 training images and 3,646 validation images, and I kept a test set aside for later, for when I want to check the model on data it has truly never touched.

random.seed(42)

if SAMPLE_SIZE is None or SAMPLE_SIZE >= len(labeled):
    sample = labeled
else:
    random.shuffle(labeled)
    sample = labeled[:SAMPLE_SIZE]

split = int(len(sample) * 0.85)
train_imgs = sample[:split]
val_imgs = sample[split:]

If slicing is new to you, sample[:split] means everything from the start up to the split point, so the first 85 percent, and sample[split:] is the rest.

There is something in this code that I only noticed while writing this post, which is that the seed only matters if something random happens after it. In the 5k pilot the shuffle ran, so the seed made the sample reproducible, but in the full run I used every labelled image, so the code took the first branch, the shuffle never ran, and the split was simply the first 85 percent of a sorted file list against the last 15 percent. If your images are saved in dataset order, your validation set may come mostly from the last dataset or two instead of being a fair mix, so I would shuffle before splitting, ideally stratified by source dataset, and compare class counts in train against validation before trusting any score.

The YAML file then tells YOLO where everything is.

path: /content/data
train: train/images
val: val/images
nc: 94
names: [apple, asparagus, avocado, ...]

Saving a checkpoint to Drive

Once the clean split was ready, I zipped it up and saved it to Drive as a checkpoint.

subprocess.run(['zip', '-q', '-r', CLEAN_ZIP_OUT, 'train', 'val', 'dataset.yaml'],
               cwd='/content/data')

I also made a Fast Resume cell that mounts Drive, unzips this file and restores the variables, so after a disconnect I can skip everything above and go straight to evaluation or training, and if you have ever lost a Colab session in the middle of a long job, you will know exactly why that cell exists.

The baseline

With the data ready, I ran a baseline, which is simply the off-the-shelf model evaluated on my validation set.

baseline_model = YOLO('yolo26n.pt')
baseline_results = baseline_model.val(data=YAML_PATH, imgsz=640, batch=16, device=0)

YOLO26n is the nano variant, with 122 layers, about 2.4 million parameters and 5.4 GFLOPs, and it comes pretrained on COCO, which has 80 general classes like person, car and laptop.

On my pilot validation set the baseline scored almost nothing, with mAP@50 around 0.0004, and I should be honest about what that tells you, which is not that the pretrained model is bad at your objects. COCO's class IDs and my class IDs do not line up, so the model gets marked wrong for predicting labels from a completely different list, and what the baseline really confirms is that the two label systems do not match. A fairer baseline would map the handful of overlapping classes, like apple, banana, orange, broccoli and carrot, and score only those, and since I did not do that, I treat my baseline as a sanity check and not as a competitor.

The training run

Then came the training run itself.

results = train_model.train(
    data=YAML_PATH,
    epochs=epochs,
    imgsz=640,
    batch=16,
    workers=2,
    patience=patience,
    device=0,
    pretrained=True,
    optimizer='AdamW',
    lr0=0.001,
    cos_lr=True,
    augment=True,
    mixup=0.1,
    copy_paste=0.1,
)

I scaled the schedule to the data, so the 5k pilot used 20 epochs with a patience of 10 and anything larger used 100 epochs with a patience of 25, and here is what each of the main settings is doing.

epochs. One epoch is one full pass through the training set, so 100 epochs means the model gets to see every training image 100 times.

batch=16. Instead of looking at one image at a time, the model sees 16 together and averages the learning signal, which is steadier and makes better use of the GPU, and if you hit a CUDA out of memory error you can drop it to 8.

optimizer='AdamW'. The optimizer decides how the weights change after each batch, and AdamW adapts per weight, making bigger moves for weights that have barely changed and smaller moves for the ones that are already well tuned.

lr0=0.001. The learning rate sets the size of each adjustment, and if it is too high the model overshoots and never settles, while if it is too low it learns painfully slowly.

cos_lr=True. Rather than staying fixed, the learning rate follows a cosine curve from 0.001 down towards zero, so the early epochs make big moves and the later ones make small refinements.

augment, mixup and copy_paste. Ultralytics flips, crops, recolours and distorts images as it trains, mixup blends two images together, and copy-paste lifts objects out of one image and drops them into another, so the model is pushed to learn features that hold up instead of memorising specific photos.

patience. If validation does not improve for that many epochs in a row, training stops on its own.

pretrained=True. The model starts from the COCO weights, so it already knows edges, textures and shapes, and training teaches it to apply that knowledge to your own classes.

What the runs showed

The 5k pilot took about half an hour and ended with mAP@50 of roughly 0.25, and it was still improving when it stopped, which told me 20 epochs was too few. The full run on about 20k images took around eight minutes per epoch on the T4, climbed quickly at first and then slowed down, and after 35 epochs it had reached about two thirds on mAP@50, while a full 100 epochs would take well over twelve hours, which is more than a Colab session likes to give you, so checkpointing to Drive really matters.

I would not read too much into the gap between those two numbers, because the runs differ in validation set, number of classes, blur threshold and amount of data all at once, so I cannot say how much of the jump came from more data and how much from the cleaner setup, and the pilot was only ever built to prove the pipeline, which it did.

The per-class results from the pilot were uneven, with orange, meat, mango, apple and peach doing well at roughly 0.75 to 0.82 on mAP@50, while pizza, hamburger and cooking spray did badly, all below 0.1, and several rare classes had only one to three validation images, which is too few to score honestly.

It is also worth being clear about what this system can and cannot do, because it flags what it sees, so it can say an item looks spoiled or that something is not food, but it cannot read a use-by date or tell you an item is safe, and with recall in the region of two thirds it will miss some objects, which means counts will tend to run low, so I treat it as a helper and never as a final check.

Making it work without internet

Running on a phone or an iPad is the reason I went with the nano variant, since YOLO26n has few enough parameters to run on mobile hardware, and exporting at 640 by 640 gives the model a fixed and predictable input shape.

Once training is done, I export the best weights to ONNX, a portable format that runs locally with no server and no connection.

model = YOLO('runs/best.pt')
model.export(format='onnx', imgsz=640, dynamic=False, simplify=True)

Setting dynamic=False fixes the input size and simplify=True trims the graph, and both help on small devices, so after the export the app only needs the ONNX file and a runtime, and all of the inference happens on the phone or iPad itself. The app also has to prepare each camera frame the same way I prepared the training images, with the same letterboxing to 640 by 640 and the same grey padding, otherwise the boxes will not line up with what the camera sees.

What I would do differently

Looking back, there are a few things I would change. I would shuffle before splitting and split by source dataset so that every dataset shows up in both sets, I would build a fairer baseline using the classes COCO and my labels share, and I would replace the duplicate check with something faster than comparing against every earlier hash. I would also hold out a proper test set, because right now the validation set is doing two jobs, and I would change one thing at a time between runs so I can tell what actually helped.

The biggest lesson for me is that the cleaning and the class unification took far longer than the training and changed the result far more, so if you are about to train on data from several places, that is where your time is best spent.

I just published Part 1 of "The Machine Learning Engineering Series", where I break down the full lifecycle: how raw data becomes a trained model, gets containerised, and ships as a live API that other engineers can actually build on.

Michellebuchiokonicha — Tue, 26 May 2026 07:38:04 +0000

Michellebuchiokonicha

May 26

The Machine Learning Engineering Series

#ai #machinelearning #deeplearning #software

5 min read

The Machine Learning Engineering Series

Michellebuchiokonicha — Tue, 26 May 2026 07:33:01 +0000

Part 1: From Scratch to Systems

.
This machine learning series will be a real ride. It’s an interactive journey where I’ll be sharing and raising lots of questions while building real-world AI systems. My goal is to make this deeply engaging, drive home the right questions, and bridge the gap between AI theory and engineering reality.

Note: There will be follow-up videos complementing this series, so keep an eye out for video links as they are released!

Let’s start at the very beginning.

Differentiating the Field: Who Does What?

There is massive confusion in the tech industry right now regarding job titles. To understand what a Machine Learning Engineer (MLE) actually does, we have to look at how they fit alongside Data Scientists and AI Software Engineers.

1. The Machine Learning Engineer (MLE)
An MLE is a specialised software engineer responsible for researching, building, scaling, and deploying machine learning models. They sit firmly at the intersection of software engineering, data science, and infrastructure.

Their core responsibilities include:

Model Development: designing and training algorithms and deep neural networks.

Data Preparation: cleaning, organising, and transforming large datasets.

Production Deployment & MLOps: deploying models to the cloud and continuously monitoring their performance.

System Architecture: building the core application infrastructure so these models can be used reliably at scale.

2. The Data Scientist (DS)
A Data Scientist is primarily focused on research, statistics, and business analysis. While an MLE is focused on specialised software engineering and scalability, a Data Scientist spends their time exploring raw data, testing hypotheses, and building prototype models to prove a business concept works.

3. The AI Software Engineer
An AI Software Engineer focuses on integration and utility. They treat machine learning models as powerful building blocks. Their primary job is to build the application frontends, backends, and user experiences that consume AI capabilities (often via external APIs), rather than training the core models from scratch.

The Core Blueprint: What You Need to Know

Most successful ML Engineers start as traditional software engineers who specialise, or are builders who learn the entire technical stack from the ground up. If you want to excel as an MLE, these are the core requirements:

Programming Languages: Python is the non-negotiable standard of the discipline. However, depending on the organisation and performance needs, some MLEs are also highly skilled in Java or C++.

ML Frameworks: you must be comfortable navigating production-grade libraries like PyTorch, TensorFlow, Keras, and scikit-learn.
Mathematics & Statistics: This is the area where many engineers fall short. While you might not be quizzed on complex proofs in every interview, understanding linear algebra, calculus, and probability is vital for debugging model behaviour.

Infrastructure & Tooling: You need to be comfortable with cloud computing platforms (GCP, AWS, etc.). Version control (Git/GitHub) is essential for managing your work, and Docker is effectively mandatory for containerising applications.

Understanding the Data

Before a system can learn, we have to understand the raw material. Data is broadly classified into two categories:

Structured Data: highly organised data that easily fits into rows and columns (e.g., CSV files, SQL databases).

Unstructured Data: complex data that does not have a pre-defined structure (e.g., images, audio, and natural language text).

The mechanics, architectures, and training pipelines required for unstructured data are entirely different from those used for structured data.

The Machine Learning Engineering Pipeline

Here is the bird’s eye view of how a model evolves from raw data into a living system:

Data ➔ Clean & Transform ➔ Analyse ➔ Baseline vs. Custom Model ➔ Train & Test ➔ Containerise & Deploy ➔ Expose as API

1. Ingestion & Analysis

Gathering Data: highly dependent on your organisation’s size. Sometimes this is handled by Data Engineers, but an MLE must know how to pull and ingest data independently.

Cleaning and Organising: raw data is messy. Here, data is cleaned, structured, and transformed into features. We will dive incredibly deep into this layer later in this series.

Exploratory Data Analysis (EDA): an MLE must thoroughly analyse data distributions and shapes before moving to the modelling phase.

2. The Modelling Strategy (Baseline vs. Custom)
When designing a system, you never just train a model blindly. You start with a baseline model.
A baseline can be an existing state-of-the-art architecture or a previously developed model. The ultimate goal of training a custom model is to prove it can outperform your baseline. If your complex custom model performs worse than a simple baseline, it shouldn’t go into production.

3. Training, Testing, and the “Skew” Bug
Training is heavily dependent on the data type and requires a deep understanding of concepts like epochs, loss functions, and regularisation techniques such as dropout (which help prevent overfitting).

Once trained, we must rigorously evaluate the model. Beyond traditional software bugs, MLEs face unique production challenges like training-serving skew.

What is training-serving skew?
This occurs when the data a model encounters in production (real life) is significantly different from the data it was trained on. This causes performance to plummet and can lead to the model producing unreliable or low-quality predictions. An MLE’s job is to ensure the training data is adequate and representative to minimise this skew.

You must also master evaluation metrics to track success, including the confusion matrix (precision, recall, accuracy, F1-score) and mAP (mean average precision) for spatial / object-detection systems.

4. Conversion to APIs & Building Systems
A model sitting on your local machine is useless. An MLE transforms a trained model into a lightweight, usable form by converting it into an API (using frameworks like FastAPI).

This makes the model highly accessible, allowing other software engineers or IoT infrastructures to seamlessly integrate its AI capabilities into a broader system.

5. Production Testing (Ensuring Utility)
Our job isn’t done just because the system runs. It must be reliable, secure, and useful. A system builder must implement a strict testing hierarchy to protect against vulnerabilities and low-standard features:

Unit Testing: testing individual components and functions in isolation.

Integration Testing: ensuring the data pipeline, API, and model interact perfectly.

Smoke Testing: rapidly verifying that the core infrastructure doesn’t crash upon deployment.

Testing isn’t just the icing on the cake; it is the foundational requirement for safety, reliability, and engineering confidence.

6. The Core Paradigms: From Linear Regression to Clustering
As we dive deeper into modelling throughout this series, we will break down the core learning paradigms that power these systems. You can’t build advanced architectures without mastering the fundamentals:

Supervised Learning: training models on labelled data (where the system knows the correct answers during training). This includes foundational algorithms like linear regression for predicting continuous values, all the way up to complex neural networks.

Unsupervised Learning: giving the model raw, unlabelled data and letting it discover hidden structures on its own. A prime example of this is clustering, where the system automatically groups similar data points without human intervention.

What’s Next?

Throughout this series, we are going to cover all of these concepts in depth. We will write the code, sketch the architectures, look at how these systems impact modern workplaces, and discuss how to position these skills to land an elite MLE role.
Buckle up, this is going to be an incredible build.

Google I/O 2026: From Consumer to Builder

Michellebuchiokonicha — Wed, 20 May 2026 19:41:08 +0000

I often tune in to Google I/O. But this year felt different.

In the past, I watched as a consumer. I needed the updates, first to keep up, then to pass them on to my audience. I was a distributor of news, a passive relay between Google's stage and other people's feeds.

This year, my pen hit the paper differently.

I watched as a builder. I wasn't tracking announcements to repeat them; I was scanning each one for where I fit, where I could come in, and how. I took pages of hurried notes, not to summarize later, but to return to and explore. Somewhere between the keynote's opening and its close, a quiet shift happened: I stopped feeling like an observer of the future and started feeling like a participant in it.

Here's what I saw, and why it mattered to me.

The Foundations Got Heavier

The keynote leaned hard on raw capability, the infrastructure underneath everything else. When the talk turned to the computing powering this new generation of models, I didn't just hear "faster." I heard the heavy-lifting engine for the deep, custom architectures I've been turning over in my head. The horsepower is finally scaling to match the complexity of what's coming.

Then came the models. Seeing Gemini 3.5 Flash and Gemini Omni Flash stream across the screen made me lean forward. Gemini 3.5 Flash pairs frontier intelligence with the ability to actually act , Google says it outperforms the previous Pro generation on coding and agentic benchmarks while running several times faster. Gemini Omni, meanwhile, takes image, audio, video, and text as input and generates editable video grounded in real-world knowledge.

For anyone building fast, reactive systems, that combination, native multimodality plus low latency, is the holy grail. We are moving past models that guess at the next word toward models that understand and generate across every modality at once.

From Assistants to Autonomous Digital Lives

The real turn in the keynote was the move from conversational assistants to agentic workflows.

This is where Gemini Spark came in, Google's pitch for a 24/7 personal agent that manages your digital life in the background. The framing that stuck with me: you can close your laptop, and the work keeps going. It feels less like a tool you pick up and put down, and more like an environment that runs on your behalf.

To make that practical, it leans on the Model Context Protocol (MCP) to integrate with third-party tools. I scribbled a question in my margin: Is this just an advanced Siri?

My conclusion: no. This is a genuine paradigm shift. But — and I underlined this, as a builder, I still believe keeping a human in the loop is non-negotiable for high-stakes decisions. An agent that acts while you sleep is powerful. It's also exactly the kind of system where the cost of a silent mistake is highest.

Agentic Commerce Gets Real

The commerce announcements immediately tested that belief.

Google introduced Universal Cart, an intelligent shopping cart that follows you across Search, Gemini, YouTube, and Gmail, tracking price drops and restocks in the background. Underneath it sit two protocols: the Universal Commerce Protocol (UCP), a common language for agent-driven checkout, and the Agent Payments Protocol (AP2), which lets agents complete purchases on your behalf within guardrails you set, specific brands, specific products, a spending cap.

AP2 builds a tamper-proof, verifiable record linking shopper, merchant, and payment processor. As an engineer, that's the part I find genuinely interesting: it's the bridge between a model that thinks and a model that securely transacts.

But it's worth being clear-eyed. Reporters covering I/O framed Universal Cart as Google's bid to become the default middleman in online commerce, a market some analysts project in the trillions by the end of the decade. Some retailers are already reporting traffic shifts as shoppers move from search to agents. The engineering opportunity here is enormous: end-to-end transaction systems where the agent owns the whole procurement and verification lifecycle. The responsibility that comes with it is just as large.

Sensory Interfaces and Immersive Wearables

A few updates pointed at where the interface itself is going.

Neural Expressive, Gemini's new design language brings adaptive emotional pacing to voices, fluid animation, and haptic feedback, making real-time audio dialogue feel noticeably more lifelike. And the Intelligent Eyewear running on Android XR moves the assistant off the screen entirely and into your physical space, directions, texts, and photos, all from a pair of glasses.

On the creative side, Flow Music stood out: a sandbox for composing original, high-fidelity songs through prompt-based collaboration. The audio modality is becoming completely fluid.

Trust, Verification, and the Hard Engineering Track

What reassured me was that the keynote didn't only sell capability, it addressed guardrails.

The expansion of C2PA Content Credentials means you can verify whether a piece of content is an unaltered original or has been modified, a check that extends all the way down to validating research and academic material. In a year defined by generative everything, provenance isn't a footnote. It's infrastructure.

Tooling for developers got attention too, including the agent-first work on Google's Antigravity platform, a sign that "anyone can be a builder" wasn't just a tagline but a thing Google is actively engineering toward.

My Final Reflection

I closed my notebook with pages of short, hurried notes. But I walked away with something more useful than notes: a map.

For the first time, I wasn't just watching Google build the future. I was figuring out exactly where I'm going to build in it, which protocols to learn, which models to prototype against, which problems are now finally tractable.

The shift from consumer to contributor doesn't happen with a single announcement. It happens the moment you stop asking "what did they release?" and start asking "what can I make with this?"

This year, I started asking the second question.

Were you watching I/O 2026? I'd love to hear which announcement made you lean forward, drop it in the comments.

I have been struggling to write…

Michellebuchiokonicha — Sat, 28 Feb 2026 08:22:51 +0000

I have been writing technical articles since 2022. My passion for technology has been built on writing. I have loved it even before I realized I wanted to go into software development. I used to write poems that got published while in school, so writing technical articles when I started coding was not a big deal for me. I have always written.

In fact, my parents used to say I would be like Chimamanda Adichie. Because not only did I know how to coin words, I knew how to express them in speech, and I also loved to read, which helped me greatly in writing with ease. At some point, while in secondary school, I considered becoming a writer and studying Literature just so I could write and speak. It always gave me joy.

But recently, I find myself struggling to do one of the things I would normally term ‘easiest’ to do.

This struggle started creeping in gradually in 2024. When ChatGPT came on board.
I still continued writing, and I had my articles featured on Dev. to amongst the 7 most read articles.

Some of my articles climbed to 40,000 reads, numerous comments, and likes. And in 2025, my new article also got featured on hasnode but in the heat of AI and arguments on AI being able to do everything, I wrote only two articles, and I paused.

I was confused, I was in doubt, I had questions: “Will people need to read articles on asynchronous functions, supervised learning, JavaScript, Python, and more, if AI can simply provide all the information?”

Secondly, I was confused because I have been a web developer all this time. Mostly writing and building frontend applications, hence most of my articles covered the web and JavaScript. But with this new excitement, I didn’t just want to stick only to the web; I wanted to branch into machine learning. This also made me pause to reflect. What started as a short-term pause in February 2025 turned into a full year of not writing any technical articles. I feel like crying as I type this. It hurts me more than I ever thought it would.

I have many excuses. Another would definitely be that I want to start a YouTube channel and be active on social media instead of writing. But I have asked so many questions. Can I edit videos? Do I really want to keep talking and explaining technology concepts instead of simply penning them down as articles? And right now, it has dawned on me. I don’t know how consistent I can be with explaining concepts via speech as opposed to writing them down, which is easier and smoother for me.
I have been stalling, waiting, postponing this, telling myself I am too busy, telling myself AI can explain everything, telling myself YouTube is better now, as people don’t read anymore. But it feels like something is missing. Like, I am not doing one of the things I am meant to be doing, and it hurts, it breaks my heart so much.

This is my first piece in one year, and truly, this morning, 7:50 am, 22nd February, 2026, thinking deeply about what could have been if I had not stopped writing, I decided to just write.

I have no will for any aspire to perspire, but I guess we will all figure it out. The questions, the doubts. If you are like me, then write.

JUST WRITE.

Infrastructure as Code: Getting Started with Terraform for Cloud Deployment

Michellebuchiokonicha — Fri, 14 Feb 2025 06:55:29 +0000

Introduction to Cloud Services

Cloud computing has changed the way we deploy and manage applications. It offers various service models to meet different needs.

Infrastructure as a Service (IaaS): Provides on-demand access to computing resources like servers, storage, and networking.

Platform as a Service (PaaS): Offers hardware and software resources for cloud application development, eliminating the need to manage the underlying infrastructure.

Software as a Service (SaaS): Delivers full application stacks as a cloud service, including maintenance and management of both infrastructure and software.

Benefits of Cloud Deployment

Using the cloud for computing and deployment comes with several advantages:

Faster Time to Market: Servers can be deployed with just a few clicks, significantly accelerating the development process.

Cost Savings: By choosing the right set of services, infrastructure costs can be drastically reduced.

Data Loss Prevention: Data is stored across multiple data centers in different availability zones, ensuring redundancy and reliability.

Challenges of Cloud Deployment

While the cloud offers many benefits, there are some challenges to consider:

Vendor Lock-In: Switching cloud providers can be costly and complex, often leaving customers tied to their original vendor.

Lack of Expertise: Finding skilled cloud professionals can be difficult, as the demand for cloud expertise often outstrips supply.

Major Cloud Providers

The three largest cloud providers dominate the market:

AWS (Amazon Web Services): Holds the largest market share in the US and offers a wide range of services.

Azure: Known for its seamless integration with Microsoft products and a strong presence in Germany.

GCP (Google Cloud Platform): This has seen rapid growth over the past three years and integrates well with Google products like Google Analytics.

Deploying to the Cloud

Deploying applications in the cloud involves using a variety of services. While you can manage these services manually through the cloud console, this approach has limitations:

Complexity: Dropping or modifying services can be tedious, requiring you to navigate through multiple menus.

Lack of Replicability: Manual configurations are hard to replicate, making it difficult for others to understand or reproduce your setup.

This is where Infrastructure as Code (IaC) comes in. IaC allows you to define and manage your infrastructure using code, making it replicable, understandable, and easier to maintain.

What is Infrastructure as Code (IaC)?

Infrastructure as Code (IaC) is the practice of managing and provisioning infrastructure through code instead of manual processes. This approach has become increasingly popular, with IaC skills now appearing in job postings for roles like Data Analysts.
Popular IaC tools include:

Terraform
AWS CloudFormation
Azure Resource Manager
Google Cloud Deployment Manager

Among these, Terraform stands out due to its ability to work across multiple cloud providers, making it a versatile choice for organizations that may migrate between clouds.

Why Terraform?

Terraform is an open-source IaC tool that allows you to build, change, and version infrastructure safely and efficiently. Here’s why it’s a great choice:

Multi-Cloud Support: Terraform supports multiple cloud providers, including AWS, Azure, and GCP.

Rollback Capabilities: Infrastructure changes can be easily rolled back, minimizing downtime and risks.
Ease of Use: Terraform uses a declarative language, making it easy to learn and use. You only need a few commands to get started.

Cost Efficiency: You can stop and resume your infrastructure as needed, saving on cloud credits and usage.

Setting Up Terraform

To get started with Terraform, you’ll need:

A Cloud Provider Account: For this guide, we’ll use AWS.

Terraform Installed: Download and install Terraform from the website: https://www.terraform.io/

Example: Setting Up an S3 Bucket in AWS

Here’s an example of how to set up an S3 bucket using Terraform:

provider "aws" {
  region = "us-east-1"
}

resource "aws_s3_bucket" "example_bucket" {
  bucket = "my-unique-bucket-name"
  acl    = "private"

  versioning {
    enabled = true
  }

  tags = {
    Name        = "Example Bucket"
    Environment = "Dev"
  }
}

This code defines an S3 bucket with versioning enabled and tags for identification. You can customize it further based on your needs.
Conclusion

you need to further set up:

provider
aws_s3_bucket
aw3_s3_bucket_public_access_block
aws_s3_bucket_ownership_controls
aws_s3_bucket_acl
aws_s3_object
aws_s3_bucket_website_configuration

Here is a simple setup

provider "aws" {
    region = "us-east-1"
}

resource "aws_s3_bucket" "s3" {
    bucket = "your-bucket"
}

resource "aws_s3_bucket_public_access_block" "s3-public-block" {
    bucket = aws_s3_bucket.s3.id

    block_public_acls       = false
    block_public_policy     = false
    ignore_public_acls      = true
    restrict_public_buckets = false
}

resource "aws_s3_bucket_ownership_controls" "s3-ownership" {
    bucket = aws_s3_bucket.s3.id

    rule {
        object_ownership = "BucketOwnerPreferred"
    }
}

resource "aws_s3_bucket_acl" "s3-acl" {
    bucket = aws_s3_bucket.s3.id
    acl    = "public-read"
}

resource "aws_s3_object" "s3-object" {
    bucket       = aws_s3_bucket.s3.id
    key          = "index.html"
    source       = "index.html"
    content_type = "text/html"
    acl          = "public-read"
}

resource "aws_s3_bucket_website_configuration" "s3-website-configuration" {
    bucket = aws_s3_bucket.s3.id

    index_document {
        suffix = "index.html"
    }
}

with this simple setup, you can deploy your first web application.
I have further included a sample index.html file

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Welcome to My Website</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 0;
            padding: 0;
            background-color: #f4f4f4;
            color: #333;
            text-align: center;
        }
        header {
            background-color: #007bff;
            color: white;
            padding: 20px 0;
        }
        h1 {
            margin: 0;
        }
        main {
            padding: 20px;
        }
        footer {
            background-color: #333;
            color: white;
            padding: 10px 0;
            position: fixed;
            bottom: 0;
            width: 100%;
        }
    </style>
</head>
<body>
    <header>
        <h1>Welcome to My Website</h1>
    </header>
    <main>
        <p>Hello, world! This is a simple webpage hosted on AWS S3.</p>
        <p>Enjoy browsing!</p>
    </main>
    <footer>
        <p>&copy; 2025 My Website</p>
    </footer>
</body>
</html>

To install terraform, use:

terraform -v

then open your IDE and run terraform init

To format and validate your terraform code, run terraform fmt and
terraform validate

Next, you would need to plan and make changes with
terraform plan

To apply the changes made, run terraform apply -auto-approve

Lastly, in order to save bandwidth and when you are not using the infrastructure at a certain time, you can destroy it with

terraform destroy -auto-approve

You can further rerun/rebuild by running
terraform apply

The process is quite seamless and easy to use and understand. it saves you time, provides flexibility, and also allows other developers to see what you have done.

Infrastructure as Code, particularly with tools like Terraform, simplifies cloud deployment and management. It ensures that your infrastructure is replicable, understandable, and easy to maintain. Whether you’re working with AWS, Azure, or GCP, Terraform provides a consistent and efficient way to manage your cloud resources.
Start your IaC journey today and experience the benefits of deploying infrastructure as code!

Python OOP Made Easy: Master Object-Oriented Programming with Ease

Michellebuchiokonicha — Tue, 04 Feb 2025 07:38:22 +0000

Object-Oriented Programming (OOP) is a programming paradigm that uses objects and classes to structure software. Unlike procedural programming, which focuses on functions and procedures, OOP emphasizes using objects that encapsulate data and behavior. Python, a versatile language, fully supports OOP, making it a powerful tool for building modular, reusable, and maintainable code.

In this article, we’ll explore the basics of OOP in Python, including classes, objects, attributes, methods, inheritance, polymorphism, encapsulation, and abstraction. We’ll also dive into functional programming concepts and how they complement OOP in Python.

Python OOP Basics

What is OOP?

OOP is a programming paradigm that organizes code into classes and objects. A class is a blueprint for creating objects, while an object is an instance of a class. OOP promotes concepts like modularity, reusability, and abstraction, making it easier to manage complex systems.

Pros of Object-Oriented Programming

Modularity: Code is organized into reusable components.

Abstraction: Hide complex implementation details.

Maintenance: Easier to update and debug.

Reusability: Classes can be reused across projects.

Cons of Object-Oriented Programming

Complexity: This can be overkill for simple programs.

Performance: Slightly slower due to overhead.

Overuse: Not every problem requires an OOP solution.

Classes and Objects in Python

What are Classes and Objects?

A class is a blueprint for creating objects. It defines the attributes (data) and methods (functions) that the objects will have. An object is an instance of a class.

Example:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hi(self):
        print(f"Hi, my name is {self.name} and I’m {self.age} years old.")

# Creating objects
person1 = Person("Alice", 25)
person2 = Person("Bob", 35)

person1.say_hi()  # Output: Hi, my name is Alice and I’m 25 years old.
person2.say_hi()  # Output: Hi, my name is Bob and I’m 35 years old.

What Can Go Wrong?

Python is flexible, but this can lead to mistakes. For example:

person3 = Person(name="Charlie", age=person1)
person3.say_hi()  # Output: Hi, my name is Charlie and I’m <__main__.Person object at 0x109f301c0> years old.

Here, age is mistakenly assigned an object instead of a number. Always validate inputs!

Attributes and Methods

Attributes

Attributes define the state of an object. They store data associated with the object.

Methods
Methods define the behavior of an object. They are functions attached to a class.

class Car:
    wheels = 4  # Class attribute

    def __init__(self, make, model, year=None):
        self.make = make  # Instance attribute
        self.model = model
        self.year = year

    def get_make_model(self):  # Instance method
        return f"{self.make} {self.model}"

car1 = Car("Toyota", "Camry", 2021)
print(car1.get_make_model())  # Output: Toyota Camry

Inheritance in Python

Inheritance allows a class (child) to inherit attributes and methods from another class (parent). This promotes code reuse and hierarchy.

Example:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("This animal speaks.")

class Dog(Animal):
    def speak(self):
        print("Woof!")

dog = Dog("Pelle")
dog.speak()  # Output: Woof!

Polymorphism, Encapsulation, and Abstraction

Polymorphism

Polymorphism allows objects of different classes to be treated as objects of a common superclass. For example:

def make_animal_speak(animal):
    animal.speak()

dog = Dog("Fido")
cat = Cat("Whiskers")

make_animal_speak(dog)  # Output: Woof!
make_animal_speak(cat)  # Output: Meow!

Encapsulation

Encapsulation hides the internal state of an object and restricts direct access. Use private attributes (__) to enforce this:

class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

Abstraction

Abstraction focuses on hiding non-essential details and exposing only the necessary features. Use abstract classes to define interfaces:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

Functional Programming in Python

Python also supports functional programming (FP), which emphasizes immutability and pure functions. Key concepts include:

Pure Functions: No side effects, deterministic.

Higher-order functions: Functions that take other functions as arguments.

Immutability: Data cannot be changed after creation.

Example:

# Higher-order functions
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))  # Output: [1, 4, 9, 16, 25]

Conclusion

OOP and FP are powerful paradigms that can be used together to write clean, modular, and maintainable code in Python. By understanding classes, objects, inheritance, polymorphism, encapsulation, and abstraction, you can build robust applications. Additionally, functional programming concepts like immutability and higher-order functions can complement OOP to make your code even more expressive.

Whether you’re building a small script or a large-scale application, mastering these concepts will help you write better Python code.

Are Web APIs the same as REST APIs? How to Improve your Web Apps with Web APIs

Michellebuchiokonicha — Tue, 14 Jan 2025 08:36:11 +0000

To answer the question simply: No, Web APIs are not the same as REST APIs.

Web APIs refer to interfaces that allow applications to interact with the web or devices. This term is broad and can refer to Browser APIs (like WebRTC or Geolocation) or Server APIs (like REST or GraphQL).

On the other hand, REST APIs are a specific type of Server API that adhere to REST principles, focusing on statelessness, resource-based communication, and using HTTP methods like GET, POST, and DELETE.

The Evolution of the Web

Originally, the web was designed as a static site for providing information and connecting individuals to relevant resources, regardless of location. However, it has evolved to become interactive and progressive, with certain aspects also turning decentralized.
This article focuses on the web being progressive and more user-friendly.

The Role of Web APIs in Modern Development

Web APIs serve as the backbone of modern web development. With APIs like WebRTC, Web Bluetooth, and Service Workers, developers can create highly interactive, native-like web applications without requiring external plugins. These capabilities make Progressive Web Apps (PWAs) possible, bridging the gap between web and native apps.
Check out my extensive article on progressive web apps.
https://dev.to/michellebuchiokonicha/how-to-get-started-with-progressive-web-apps-3f44

Some Benefits of Progressive Web Apps

Works on any browser (cross-platform)
Responsive to any device
Functions without network connectivity
Performs like a mobile app
Highly secure
Discoverable via search engines
Boosts app engagement
No installation required
Can be shared through a link
Optionally available on app stores (e.g., Google Play, Apple Store)

Web APIs and Project Fugu

Web APIs here, referring to browser APIs, act as connectors, improvers, and builders for the browser's capabilities. These APIs are inherent to the web and are not third-party APIs purchased from libraries or sites. Instead, they are broadly available and designed to improve the web and enhance products created by developers, reducing boilerplate code and simplifying web interactions.
The significance of web APIs is underscored by the fact that over 70% of activities conducted online occur through the web, highlighting the need for improvements and scalability.

In summary, web APIs are crucial for the success of Progressive Web Apps and the future of web development. They act as enablers of advanced functionalities.

Project Fugu

Project Fugu derives its name from the Japanese word for pufferfish, "fugu."
Initially, I was curious about why this project was named after a fish until I learned more about it. The fugu is a dangerous fish that can be delicious when prepared correctly; however, if not handled properly, it can be harmful. This metaphor aptly reflects the project's goal of enhancing the web platform's capabilities to match those of native applications.
The correlation here is that the Project Fugu APIs aim to enrich the web (the ‘delicious’ aspect), and if they are not built correctly (the ‘preparation’), they can introduce significant security vulnerabilities. Imagine creating an API accessible to billions without adequate security measures; it would expose individuals to various security risks.

You can find more about Project Fugu and its APIs at https://developer.chrome.com/docs/capabilities/fugu-showcase. Here, you will discover interesting and exciting projects built with web APIs, as well as a comprehensive list of available APIs. Many native app features that were previously unavailable on the web are now accessible, thanks to web APIs.

Why Web APIs?

Web APIs are crucial for several reasons, and their importance should not be overlooked. They empower the browser, transforming the web from a simple content viewer into a powerful application platform. With APIs like WebRTC, WebSockets, Service Workers, Web Bluetooth, and Web XR, you can now accomplish tasks on the web that were once limited to native applications.

Why Should You Start Using Web APIs?

Web APIs offer numerous benefits, including:

Access to Native Device Features: They allow you to access device hardware such as cameras, microphones, sensors, and Bluetooth devices. This means you can make video calls, control robots, and experience augmented reality directly in your browser, without needing to download any apps.

Offline and Background Functionality: Service Workers enable features like push notifications and caching, enhancing the user experience even when offline.

Simplified App Development for Cross-Platforms: Web APIs facilitate easier development across different platforms.

How Web APIs Improve the Web

Web APIs bring the capabilities of native apps to the web, granting access to powerful features without requiring installations or downloads. They also help future-proof the web; as browsers evolve, more APIs will be developed for seamless integration. Additionally, web APIs are accessible across platforms.

Is it Easy to Get Started with Web APIs?

Yes, it is straightforward. Most web APIs are already integrated into browsers, and supported by robust documentation. Since many are native to the browser, there's no need for third-party libraries or installations. This makes getting started seamless, consistent, and accessible across platforms.

Some Web APIs

Web APIs are the cornerstone of the Progressive Web App (PWA) revolution. They form the backbone of improved web functionality and represent the future of web development. Numerous Web APIs are available, and you can find a comprehensive list in the MDN documentation or on web.dev. Below are about 10 Web APIs to help you understand how they work. You can find many more in the MDN docs,web.dev, or via the project fugu documentation.

WebRTC API: Enables real-time audio, video, and data communication directly between browsers without the need for external plugins. It is commonly used for video conferencing and peer-to-peer file sharing.

Web Bluetooth API: Allows websites to communicate with Bluetooth-enabled devices, such as fitness trackers, medical devices, and IoT gadgets.

WebXR API: Provides support for immersive technologies like Virtual Reality (VR) and Augmented Reality (AR), allowing developers to create engaging 3D experiences directly in the browser.

WebSocket API: Facilitates full-duplex communication between the client and server, making it ideal for real-time applications like chat systems, live streaming, and collaborative editing.

Push Notification API: Enables websites to send timely and relevant notifications to users even when the website is not open in the browser, enhancing user engagement.

Web Share API: Provides a standardized way for web apps to share content using native sharing mechanisms, making it easier to share links, files, or text with other applications.

Fetch API: Replaces the older XMLHttpRequest and simplifies asynchronous data fetching.

Web Payment API: Simplifies the online payment process by offering a consistent interface for users to make payments using various methods, such as credit cards or digital wallets.

Geolocation API: Provides access to the geographical location of the user, enabling location-aware functionality like maps, location-based recommendations, or geofencing.

File System Access API: Enables web applications to read from and write to the user’s local file system, creating a native-like experience for file manipulation.

WebRTC Demo

WebRTC enables real-time communication, including audio, video, and data-sharing capabilities. For a simple WebRTC demo, you will need:

index.html

app.js

server.js

WebSocket or HTTP REST API
Inbuilt WebRTC API
Local and remote video elements
Buttons to manage peer connections
WebRTC configurations

How It Works

Access User's Camera and Microphone: Create a function to access the user's camera and microphone, displaying the local stream on the local video element.

Peer Connection: Implement a function to handle media exchange.

Signaling: Simulate sending and receiving data through the signaling server.

Remote Stream Handling: Display the remote track in the remote video element.
ICE Candidates: Exchange these candidates with peers to establish a connection.

Web APIs are the cornerstone of modern web development, enabling developers to build powerful, scalable, and engaging applications. Whether you're exploring WebRTC for real-time communication or leveraging the File System Access API for native-like experiences, the possibilities are vast. Start experimenting today and contribute to the web's progression.

How to Automate Excel Files from APIs with Python and Openpyxl.

Michellebuchiokonicha — Fri, 16 Aug 2024 06:30:41 +0000

Automation in programming is the use of programming languages like Python, VBA, and other technology tools to create programs, scripts, or various tools that perform automatic tasks with no manual intervention.
The sole purpose of automating tasks is to avoid manual input and to ensure various systems run by themselves.

For this article, I will provide a step-by-step guide on how I automated an Excel file, and different sheets on a MacBook, without visual basic for applications, using Python in this case.

First of all, to get started, you don't need to be a Python dev as I will paste a code snippet here.

Tools Required

VScode of course
Python installed/updated
A virtual environment to run any new installation or updates for your Python code.
The virtual environment is the .venv. You will see it in your vscode.
Install openpyxyl
Install any other necessary dependency.
Get started.

The Different Aspects we will be considering:

Creating a new Excel file with python
Updating an existing Excel file with python Updating a specific Excel file sheet only with Python
Using APIs to update Excel files and Excel file sheets.
Creating a button that allows users to update on click.
Adding dynamic dates and time in your code
An alternative to the Excel button is cron or Windows shell
Instead of VBA, what else is possible?
Issues faced with writing VBA in a MacBook
Issues I faced while creating the button
Why I opted for cron
Creating this for both Windows and Mac users
Other tools that can be used for the automation of Excel
Power query from web feature
Power automate
Visual Basic in Excel

Creating a new Excel file with python

Creating an Excel sheet in Python with openpyxl is easy.
All you need to do is install openpyxl, pandas, and requests if you are getting data from an API.
Go to the openpyxl documentation to learn how to import it into your application and the packages you want to use.

import pandas
import requests
from openpyxl import Workbook, load_workbook
from openpyxl.utils import get_column_letter

Next up,
you create a new workbook
Set it as the active workbook
Add your title and header and populate the data
Save the new workbook with your preferred Excel name and tada!
you have created your first Excel file.

# create a new workbook
wb = Workbook()
ws = wb.active
ws.title = "Data"

ws.append(['Tim', 'Is', 'Great', '!'])
ws.append(['Sam', 'Is', 'Great', '!'])
ws.append(['John', 'Is', 'Great', '!'])
ws.append(['Mimi', 'Is', 'Great', '!'])
wb.save('mimi.xlsx')

Creating a new sheet in an Excel file.

Creating a specific sheet in your Excel file is a similar process. however, you need to specify the sheet to be created with a sheetname.

# create sheet
wb.create_sheet('Test')
print(wb.sheetnames)

Modifying an Excel sheet.

To modify an Excel sheet and not the full file,

Load the workbook you want to modify
They specify the particular sheet to modify using its name or index. It is safer to use the index in case the name eventually changes.
In the code snippet below, I used the Sheet label

# wb = load_workbook('mimi.xlsx')

# modify sheet
ws = wb.active
ws['A1'].value = "Test"
print(ws['A1'].value)
wb.save('mimi.xlsx')

Accessing multiple cells

To access multiple cells,
Load the workbook
Make it the active workbook
loop through its rows and columns

# Accessing multiple cells
 wb = load_workbook('mimi.xlsx')
 ws = wb.active

 for row in range(1, 11):
     for col in range(1, 5):
         char = get_column_letter(col)
         ws[char + str(row)] = char + str(row)
         print(ws[char + str(row)].value)

 wb.save('mimi.xlsx')

Merging Excel cells

To merge different cells in Excel using Python,
Load the workbook
Indicate the active workbook
indicate the cells you want to merge

# Merging excel cells
wb = load_workbook('mimi.xlsx')
ws = wb.active

ws.merge_cells("A1:D2")
wb.save("mimi.xlsx")

Unmerging cells

To unmerge different cells in Excel using python,
Load the workbook
Indicate the active workbook
indicate the cells you want to unmerge

# merging excel cells
wb = load_workbook('mimi.xlsx')
ws = wb.active

ws.unmerge_cells("A1:D1")
wb.save("mimi.xlsx")

Inserting new excel cells

To insert new cells

Load the workbook
Indicate the active workbook
use the insert_rows and insert_columns to insert new rows or new columns based on preference.

# inserting cells
wb = load_workbook('mimi.xlsx')
ws = wb. is active

ws.insert_rows(7)
ws.insert_rows(7)

ws.move_range("C1:D11", rows=2, cols=2)
wb.save("mimi.xlsx")

Updating an existing Excel file with internal Data
Add your arrays and objects and take in the information needed

from openpyxl import Workbook, load_workbook
from openpyxl.utils import get_column_letter
from openpyxl.styles import Font

data = {
    "Pam" : {
        "math":65,
        "science": 78,
        "english": 98,
        "gym": 89
    },
    "Mimi" : {
        "math":55,
        "science": 72,
        "english": 88,
        "gym": 77
    },
    "Sid" : {
        "math":100,
        "science": 66,
        "english": 93,
        "gym": 74
    },
    "Love" : {
        "math":77,
        "science": 83,
        "english": 59,
        "gym": 91
    },
}

wb = Workbook()
ws = wb.active
ws.title = "Mock"
headings = ['Name'] + list(data['Joe'].keys())
ws.append(headings)

for a person in data:
    grades = list(data[person].values())
    ws.append([person] + grades)

for col in range(2, len(data['Pam']) + 2):
    char = get_column_letter(col)
    ws[char + '7'] = f"=SUM({char + '2'}:{char + '6'})/{len(data)}"

for col in range(1, 6):
    ws[get_column_letter(col) + '1'].font = Font(bold=True, color="0099CCFF")


wb.save("NewMock.xlsx")

Updating an existing Excel file with Python and APIs

To update an Excel file using Python and APIs, you need to call the APIs into your file using a Get request.
Set the active Excel file as described above and then you run your script.
Here is an example of this:

from openpyxl import Workbook, load_workbook
import requests
from datetime import datetime, timedelta

import schedule
import time

api_url = "https://yourapi"
excel_file = "yourfilename.xlsx"

def fetch_energy_data(offset=0):
    response = requests.get(api_url + f"&offset={offset}")
    data = response.json()

    if response.status_code == 200:
        data = response.json()
        return data["results"], data["total_count"] 
    else:
        print(f"Error fetching data: {response.status_code}")
        return [], 0

def update_excel_data(data):
    try:
        wb = load_workbook(excel_file)
        ws = wb.worksheets[0]  

        for row in range(5, ws.max_row + 1):  
            for col in range(1, 9):  
                ws.cell(row=row, column=col).value = None  

                now = datetime.now()
                current_year = now.year
                current_month = now.month

        start_date = datetime(current_year,current_month, 1) 
        end_date = datetime(current_year, current_month, 24) 

        filtered_data = [
            result
            for result in data
            if start_date <= datetime.fromisoformat(result["datetime"]).replace(tzinfo=None) <= end_date]


        for i, result in enumerate(filtered_data):  
            row = i + 5  
            ws[f"A{row}"] = result["datetime"]
            ws[f"B{row}"] = result["yourinfo"]
            ws[f"C{row}"] = result["yourinfo"]
            ws[f"D{row}"] = result["yourinfo"]
            ws[f"E{row}"] = result["yourinfo"]
            ws[f"F{row}"] = result["yourinfo"]  
            ws[f"G{row}"] = result["yourinfo"]
            ws[f"H{row}"] = result["yourinfo"]

        for row in range(5, ws.max_row + 1):
            ws[f"I{row}"] = ws[f"I{row}"].value  
            ws[f"J{row}"] = ws[f"J{row}"].value  
            ws[f"K{row}"] = ws[f"K{row}"].value  
            ws[f"L{row}"] = ws[f"L{row}"].value  

        wb.save(excel_file)
        print(f"Excel file updated: {excel_file}")
    except FileNotFoundError:
        print(f"Excel file not found: {excel_file}")
    except KeyError:
        print(f"Sheet 'Forecast PV' not found in the Excel file.")
    schedule.every().hour.do(update_excel_data)

    while True:
             schedule.run_pending()

if __name__ == "__main__":
    all_data = []
    offset = 0
    total_count = 0
    while True:
        data, total_count = fetch_energy_data(offset)  
        if not data:
            break
        all_data.extend(data)
        offset += 100  
        if offset >= total_count:  
            break


    update_excel_data(all_data)


To update a particular sheet, use the method mentioned above. best practices are done with the excel sheets index number from 0 till n-1.
as sheet names can change but sheet positions can not change.

 wb = load_workbook(excel_file)
        ws = wb.worksheets[0]

Creating a button that allows users to update on click. To achieve a button to automatically run your Python script, you need to create a button in your Excel file and write a program using the inbuilt programming language, Visual Basic for applications. Next, you write a program similar to this. An example of a VBA script is below.

Sub RunPythonScript()
    Dim shell As Object
    Dim pythonExe As String
    Dim scriptPath As String
    Dim command As String

     Path to your Python executable
    pythonExe = "C:\Path\To\Python\python.exe"

     Path to your Python script
    scriptPath = "C:\Path\To\Your\Script\script.py"

     Command to run the Python script
    command = pythonExe & " " & scriptPath

     Create a Shell object and run the command
    Set shell = CreateObject("WScript.Shell")
    shell.Run command, 1, True

     Clean up
    Set shell = Nothing
End Sub

the issue with this is some functions do not run in non-windows applications seeing that Excel and VBA are built and managed by Microsoft, there are inbuilt Windows functions for this that can only work on Windows.

However, if you are not writing a very complicated program, it will run properly.

Adding dynamic dates and time in your code

To achieve dynamic dates and times, you can use the date.now function built into Python.

now = datetime.now()
 current_year = now.year
current_month = now.month

An alternative to the Excel button is cron or Windows shell

For MacBook users, an alternative to the VBA and button feature, you can use a corn for MacBook and a Windows shell for Windows. to automate your task.

You can also make use of Google Clouds's scheduler. that allows you to automate tasks.

Instead of VBA, what else is possible?

Instead of VBA, direct Python codes can suffice. you can also use the script and run it as required.

Issues faced while writing VBA in a MacBook

The major issue lies in the fact that VBA is a Windows language and hence, has limited functions in a non-windows device.

Issues I faced while creating the button

The same issues are related to the VBA code.

Why I opted for cron
I opted for corn because it is available and easy to use to achieve the goals.
Other tools that can be used for the automation of Excel

Other tools include:

Power query from web feature
Power automate
Visual Basic in Excel

Follow me on Twitter Handle: https://twitter.com/mchelleOkonicha

Follow me on LinkedIn Handle: https://www.linkedin.com/in/buchi-michelle-okonicha-0a3b2b194/
Follow me on Instagram: https://www.instagram.com/michelle_okonicha/

Tips for Fixing Bugs and Resolving Code Issues.

Michellebuchiokonicha — Tue, 30 Jul 2024 01:53:52 +0000

Hey there!

These tips I have listed have worked for me and helped me resolve issues in my code. I also learn a lot while on it.

Understand the issue.
Write down the issue.
Go through the code given twice or more times.
Understand the code and its logic.
Analyze the issue based on the current code.
Device two or more ways to fix it on paper.
Write pseudocode.
Implement pseudocode in your file.
Use Debugging tools
Use Browser tools for developers like inspect, developer tools, console, etc.
Include error handling at every point
If still difficult, discuss this problem with another developer
regardless of the language used.
Sleep on the issue.
Think about the issue deeply.
Go back and fix the issue.

Sidenotes:

Research as much as you can. Someone might have fixed this issue previously. So search the internet to help you work seamlessly.

How to Improve Your Development Workflow with Gemini Code Assist

Michellebuchiokonicha — Sat, 20 Jul 2024 08:27:05 +0000

Have you ever dreamt of building and deploying applications three times faster? Look no further than Gemini Code Assist, an AI assistant from Google that empowers developers and cloud specialists throughout the development lifecycle.

What is Gemini Code Assist?

Gemini Code Assist is an AI-powered tool that streamlines the development process for software developers and cloud engineers. It integrates seamlessly with the Google Cloud platform and popular IDEs like Visual Studio Code.

Gemini Code Assist boasts a variety of features to enhance your coding experience, including:

Code Completion: It Generates code snippets and functions tailored
to your specific needs.
Code Explanation: You can Gain a deeper understanding of existing
code with clear explanations.
Code Refactoring: It Improves code readability, maintainability,
and performance with suggested optimizations.
Test Case Generation: It Automatically creates unit tests to
ensure code quality.

Get Started with Gemini Code Assist

A codelab session is available to guide you through the intricacies of using Gemini Code Assist. Here's a glimpse into what you can achieve:

https://codelabs.developers.google.com/codelabs/cloud-code-assist-sdlc#0

API Design: Describe your application's requirements, and Gemini - Code Assist will generate an appropriate architecture, complete with API routes, ports, and data types. You can even test the generated API to verify its functionality.

Full-Stack Development: Craft full-fledged applications in any programming language using natural language prompts. Gemini Code Assist can replace existing code, create new files, and cite sources for the generated code.

Automated Testing: Generate unit tests tailored to your specific needs and leverage Gemini Code Assist to help refactor code for passing tests.

Streamlined Deployment: Gemini Code Assist integrates with Google Cloud Platform for effortless application deployment, eliminating the need for manual configuration.

Benefits of Using Gemini Code Assist

Increased Development Speed: Build applications significantly
faster with code generation and completion features.
Improved Code Quality: Write cleaner, more maintainable code with
refactoring suggestions and automated testing.
Reduced Costs: Save time and resources by streamlining
development tasks.
Enhanced Developer Productivity: Focus on core development
activities while Gemini Code Assist handles repetitive tasks.

Using Gemini Code Assist

There are two primary ways to leverage Gemini Code Assist:

Google Cloud Platform: Access Gemini Code Assist directly within
the Google Cloud console for a seamless cloud-based development
experience.
Local IDE Integration: Install the Gemini Code Assist extension
for your IDE (like Visual Studio Code) to enjoy its features
within your familiar development environment.

Unique Features of Gemini Code Assist

Replace feature: Allows you to replace your existing code without copying and pasting
The update feature allows you to update and rewrite existing code
The citation feature: it cites code sources for further use and also allows the developer to know more about the code.
Explain feature: Explains highlighted code. You need to highlight it and it explains that aspect of code.
Specific use case: It creates specific use cases unique to the written code.

How To Use Gemin Code Assist In your IDE like VSCode

It is very easy and straightforward.

Go to your Visual Studio or the IDE you use
Go to Extensions
Search for Gemini Code Assist + Google Cloud Code.

Install and enable it
Click on the icon by the side

Log in or Sign up with your Chrome browser. If Chrome is not your default browser, copy it and paste it into your Chrome browser.
After which you can get started.

All the features and capabilities Listed above are fully applicable here.

Conclusion

Gemini Code Assist is a powerful and versatile tool that empowers developers and cloud specialists of all levels. It simplifies coding tasks, improves code quality, and accelerates the development process, allowing you to focus on creating innovative applications.

Follow me on Twitter Handle: https://twitter.com/mchelleOkonicha

Follow me on LinkedIn Handle: https://www.linkedin.com/in/buchi-michelle-okonicha-0a3b2b194/
Follow me on Instagram: https://www.instagram.com/michelle_okonicha/