DEV Community: Nwadiogo Emelie

LazyScrape: A Mobile-Built Python Web Scraper

Nwadiogo Emelie — Wed, 21 Oct 2026 18:57:15 +0000

This is a submission for the [MLH x DEV Writing Challenge]_This is a submission for the MLH x DEV Writing Challenge

What I Built

I built LazyScrape, a clean, lightweight web automation tool designed for mobile and low-power devices. It is a web scraper that allows users to input any URL and instantly extracts all readable paragraphs and text headers from that page, filtering out noisy background code and scripts.

Inspiration

As a 16-year-old developer working entirely from a smartphone without a laptop, I noticed how hard it is to read and study long documentation pages on small screens. I wanted to build a distraction-free tool that strips away website layouts and presents pure data cleanly.

What I Learned

During this build, I deeply mastered Python's file systems and web request logic using modern syntax. I learned how to structure backend code so that it works seamlessly with mobile-friendly HTML environments.

Demo

Since this project was built entirely on a smartphone using mobile cloud environments, you can view the live source structure here:
https://dev.to

How it Works (The Code)

Here is the core backend logic written in Python to fetch and process data securely without crashing:

import urllib.request
from html.parser import HTMLParser

# Simple, stress-free Python web fetching logic
class SimpleTextExtractor(HTMLParser):
    def __init__(self):
        super().__init__()
        self.recording = False
        self.data_chunks = []

    def handle_starttag(self, tag, attrs):
        if tag in ['p', 'h1', 'h2', 'h3']:
            self.recording = True

    def handle_endtag(self, tag):
        if tag in ['p', 'h1', 'h2', 'h3']:
            self.recording = False

    def handle_data(self, data):
        if self.recording:
            self.data_chunks.append(data.strip())

# Safe implementation code
url = "https://example.com"
try:
    with urllib.request.urlopen(url) as response:
        html_content = response.read().decode('utf-8')
        parser = SimpleTextExtractor()
        parser.feed(html_content)
        print("\n".join(filter(None, parser.data_chunks)))
except Exception as e:
    print(f"Error fetching data securely: {e}")

Partner Technologies

For this project, I utilized GitHub directly from my mobile browser to track code versions and manage my scripts cleanly. Using Git allowed me to save code updates seamlessly without worrying about local device storage limitations.

Hackathon Experience

Participating in this MLH event from Nigeria has been an incredible experience. Building a functional software solution strictly on a phone screen taught me that you don't need expensive laptop setups or desktop rigs to create valuable code. The community support on DEV motivated me to push past hardware limits and submit my work proudly!
(https://dev.to/mlh-hackathon)_

What I Built

Demo

Partner Technologies

Hackathon Experience

Mastering Flexbox: The Ultimate Stress-Free Guide to Modern Web Layouts

Nwadiogo Emelie — Tue, 20 Oct 2026 22:04:46 +0000

Mastering Flexbox: The Ultimate Stress-Free Guide to Modern Web Layouts

When you start learning HTML, everything makes complete sense until you try to position elements on a screen. For years, beginners struggled with floats, display: inline-block, and complex margin calculations just to put a sidebar next to a main content column. It was messy, unpredictable, and caused massive styling ling stress.

Enter Flexbox (The Flexible Box Layout). Flexbox is a modern CSS layout system designed to align items dynamically, distribute space evenly, and make responsive design completely effortless.

In this guide, we will look at how Flexbox works and the only 4 properties you need to master to build stunning layouts on your phone or computer.

**The Core Concept: Parent vs. Child

Before writing Flexbox code, you must understand its golden rule: Flexbox is applied to the container (the Parent), but it controls the layout of the elements inside it (the Children).

Imagine a standard HTML structure like this:

Box 1 Box 2

Box 3

By default, block elements like

stack vertically on top of each other. To activate Flexbox and tum them into an automatic horizontal row, you only need one magic line of CSS on the parent class:

.container

display: flex;

As soon as you type display: flex;, the child boxes instantly jump to line up side-by-side in a horizontal row.

The 4 Properties You Need to Know

Once Flexbox is activated, you use these 4 core properties on the parent container to control exactly how the child elements move and stretch.

⚫ flex-direction (Controlling the Layout Track): By default, Flexbox aligns items horizontally. You can change the main axis instantly using flex-direction: row; (side-by-side) or flex-direction: column; (stacked vertically).

⚫ justify-content (Horizontal Alignment): This property controls how space is distributed along the horizontal axis. It features configurations like center (packs everything in the middle), space-between (pushes items to far edges), and space-around (equal space on both sides).

⚫ align-items (Vertical Alignment): Centering items vertically used to require massive layout hacks. Flexbox solves this completely with align-items: center;, which aligns elements to the vertical midpoint of the parent.

⚫ flex-wrap (Handling Overflows): If you run out of space on a row, Flexbox defaults to shrinking your items until they look squished. Adding flex-wrap: wrap; allows items to automatically wrap cleanly onto new lines.

The Ultimate Cheat Sheet to Center Anything

.center-box {

If you ever need to center a button, text, or a login form perfectly dead-center on a page, copy and paste this

universal 3-line Flexbox setup onto the parent container:

display: flex: justify-content: center; align-items: center;

}

Conclusion

Flexbox eliminates the guesswork and stress from CSS layouts. By applying display: flex to a container and adjusting how its children align, you can create fully responsive, professional mobile layouts with minimal lines of code.

A Beginner’s Guide to Reading Text Files in Python (Without Frustration)

Nwadiogo Emelie — Tue, 20 Oct 2026 21:10:04 +0000

The Stress-Free Guide to Reading Text Files in Python

When learning Python, many beginners get stuck when trying to connect their code to the real world. One of the most useful skills you can learn early on is how to read data from a plain text (.txt) file. Whether you are analyzing a list of user names, reading configuration settings, or processing logs, Python makes file handling incredibly simple.

In this tutorial, we will look at the cleanest, most stress-free way to open and read text files using Python.

Step 1: Setting Up Your Sample File

Before writing any Python script, we need a file to read. Letâ€™s create a small sample text file.

Open any basic text editor or notes app on your device.
Type three lines of text, for example:

   Welcome to Python file handling!
   This is a clean, automated way to process data.
   Coding on your own terms is highly rewarding.

Save this file exactly as sample.txt in the same directory or folder where you plan to run your Python code.

Step 2: The Modern, Secure Way to Open Files (`with open`)

In older Python tutorials, you might see programmers open a file, read it, and then manually type file.close() at the end.

Manually closing files is stressful because if your program crashes or you simply forget to type the close command, the file stays locked in your device's memory. This can slow down your system or corrupt your data.

The modern solution is the with statement. When you use with, Python automatically closes the file for you as soon as the block of code finishes runningâ€”even if your code hits an error.

Here is the basic code structure:

# Opening the file safely using the 'with' keyword
with open("sample.txt", "r") as file:
    content = file.read()
    print(content)

Breaking Down the Code:

open("sample.txt", "r"): This function tells Python to look for our file. The "r" parameter stands for Read mode. This ensures your script safely reads the data without accidentally modifying or deleting the original text.
as file: This gives our opened file a temporary nickname (file) so we can interact with it in the next lines.
file.read(): This command tells Python to grab every single character inside the document at once and store it neatly inside a variable called content.
print(content): Finally, we output the text directly to the console or screen.

Step 3: Reading a File Line by Line

The file.read() method works perfectly for small text documents. However, if you are dealing with a massive file containing thousands of lines of data, reading everything at once will overload your system's memory.

The most efficient alternative is to process the file line by line using a standard for loop:

# Reading line by line to save memory
with open("sample.txt", "r") as file:
    for line in file:
        print(line.strip())

Why use `.strip()`?

When you press "Enter" to start a new line in a text file, an invisible newline character (\n) is added. Python's print() function also automatically adds its own newline. If you run a loop without .strip(), your output will have double spacing with empty lines between sentences.

Adding .strip() trims away all invisible spaces, tabs, and newlines, leaving you with perfectly clean text.

Conclusion

File handling in Python does not need to be complicated. By using the with open() pattern, you protect your system's memory automatically and can easily handle text datasets of any size with just a few lines of clean code.

Try running these scripts in your mobile or desktop code editor, and use them as building blocks for your next automation project!

DEV Community: Nwadiogo Emelie

LazyScrape: A Mobile-Built Python Web Scraper

What I Built

Inspiration

What I Learned

Demo

How it Works (The Code)

Partner Technologies

Hackathon Experience

What I Built

Demo

Partner Technologies

Hackathon Experience

Mastering Flexbox: The Ultimate Stress-Free Guide to Modern Web Layouts

A Beginner’s Guide to Reading Text Files in Python (Without Frustration)

The Stress-Free Guide to Reading Text Files in Python

Step 1: Setting Up Your Sample File

Step 2: The Modern, Secure Way to Open Files (with open)

Breaking Down the Code:

Step 3: Reading a File Line by Line

Why use .strip()?

Conclusion

Step 2: The Modern, Secure Way to Open Files (`with open`)

Why use `.strip()`?