DEV Community: Ebenezer Tosan

IoT to Cloud: Why Store IoT data in the cloud?

Ebenezer Tosan — Tue, 19 Aug 2025 08:30:53 +0000

In my last post on the IoT to Cloud series, we discussed the basics of IoT and Cloud from a fundamental perspective. As you know, the Internet of Things (IoT) is everywhere today—from smart home devices to sensors in vehicles and healthcare wearables. Each of these devices generates a large amount of data that needs to be collected, processed, and stored for insights. The big question here is: where should all this data go? This is where Cloud storage comes in.

Why Store IoT Data in the Cloud?

By sending IoT-generated data to the cloud, we benefit in several ways:

Scalability: The cloud can scale to handle growing volumes of IoT data.

Accessibility: Data stored in the cloud can be accessed from anywhere.

Integration: Cloud platforms connect easily with other tools such as AI, analytics, and visualization platforms.

Security: Cloud platforms are built with strong security measures, ensuring stored data remains safe.

What Are the Available Cloud Platforms for Housing IoT Data?

Several cloud platforms with IoT support are available today, and the choice of which to use depends on the user’s needs. Below are some of the most widely adopted options:

Amazon Web Services (AWS IoT Core)
Microsoft Azure IoT Hub
Google Cloud IoT Core (now being phased out but still worth mentioning for context)
IBM Watson IoT Platform

These platforms share similarities while also offering unique features for connecting IoT data to the cloud. As mentioned earlier, selecting the right platform depends on the user’s requirements.

Conclusion

In conclusion, IoT is not a new technology—it is already a part of our daily lives. While IoT provides great benefits, it also generates massive amounts of data daily. Properly storing this data is essential, and this is where Cloud storage plays a critical role.

In the next discussion, we will compare current cloud options and highlight the benefits of each as they relate to storing IoT data.

IoT & Cloud - Intro

Ebenezer Tosan — Wed, 13 Aug 2025 16:17:39 +0000

The Internet of Things (IoT) has become one of the most talked-about technologies in recent years. From smart homes to industrial automation, IoT is being applied across various domains to deliver real-time automation, enhanced security, and improved operational efficiency.

As the adoption of IoT continues to grow, so does the need for scalable solutions. This is where IoT-to-Cloud integration comes in, enabling connected devices to send data to the cloud for processing, storage, and analysis.

In this post, I’ll introduce the basic concepts of IoT and cloud computing, explain why combining them is so powerful, and give a high-level overview of how IoT-to-Cloud communication works.

Definition of Terms

The Internet of Things (IoT) refers to a network of physical devices — such as sensors, actuators, and microcontrollers — that collect and exchange data through the internet. These devices are designed to monitor, automate, and respond to real-world conditions with minimal human intervention.

As IoT ecosystems grow in size and complexity, local processing and storage quickly become insufficient. This is where cloud computing plays a critical role.

Cloud platforms offer scalable infrastructure, real-time analytics, long-term storage, and centralized control — all essential for managing large volumes of data generated by IoT devices. Integrating IoT with the cloud enables smarter decision-making, remote monitoring, predictive maintenance, and more.

The combination of IoT and cloud computing has already transformed industries such as:

Smart homes – enabling voice-controlled lights, thermostats, and appliances
Healthcare - powering remote patient monitoring and health tracking
Manufacturing – supporting predictive maintenance and asset tracking
Agriculture – improving crop monitoring and irrigation systems

To make this integration possible, lightweight and efficient communication protocols are needed. One such protocol is MQTT (Message Queuing Telemetry Transport) — a publish/subscribe messaging model ideal for IoT-to-cloud communication.

As earlier stated, this is an introduction to IoT and Cloud. In the next post we would discuss more on cloud platforms that support IoT.

Basics of ON DELETE CASCADE and ON UPDATE CASCADE in SQL - PART 1

Ebenezer Tosan — Tue, 08 Apr 2025 03:28:41 +0000

When working with relational databases, keeping data consistent across tables is critical. This is where foreign keys and referential actions like ON DELETE CASCADE and ON UPDATE CASCADE come into play.

What Are CASCADE Actions in SQL?
In SQL, when you define a foreign key relationship between two tables, you can specify what should happen when the data in the parent table is deleted or updated.

There are a few options (CASCADE, SET NULL, RESTRICT, etc.), but two of the most powerful and commonly used are:

ON DELETE CASCADE

ON UPDATE CASCADE

See breakdown below.

ON DELETE CASCADE This tells the database:

“If a record in the parent table is deleted, automatically delete the related records in the child table.”

Example Use Case:
Imagine you have two tables: Users and Posts. Each post belongs to a user.

ON UPDATE CASCADE This tells the database:

“If the primary key of the parent table is updated, automatically update all corresponding foreign keys in the child table.”

Why Update Primary Keys Though?
Usually, primary keys don’t change. But in some systems where natural keys (like usernames or codes) are used as primary keys, updates can happen.

In summary, ON DELETE and ON UPDATE CASCADE helps provide clean and consistent database.

A Guide to SOLID Principles in Software Development

Ebenezer Tosan — Tue, 25 Mar 2025 10:43:54 +0000

What is SOLID Principles?
SOLID is a set of five design principles that improve software maintainability, scalability, and flexibility. These principles help developers write clean, robust, and scalable code.

1. Single Responsibility Principle (SRP)

A class should have only one reason to change.
Each class should focus on a single responsibility. If a class is handling multiple concerns, it's harder to maintain and modify.

✅ Example: A User class should handle only user-related logic, while a UserRepository class should manage database operations.

2. Open/Closed Principle (OCP)

Software entities should be open for extension but closed for modification.
Instead of modifying existing code, extend it through inheritance or interfaces.

✅ Example: Use polymorphism to add new functionality without altering existing code.

3. Liskov Substitution Principle (LSP)

Objects of a superclass should be replaceable with objects of a subclass without breaking the system.
A subclass should enhance, not alter, the expected behavior of the parent class.

✅ Example: If Rectangle is a parent class and Square is a subclass, overriding width or height independently should not break calculations.

4. Interface Segregation Principle (ISP)

A class should not be forced to implement interfaces it doesn’t use.
Instead of one large interface, create smaller, more specific ones.

✅ Example: Instead of a MultifunctionPrinter interface with Print(), Scan(), and Fax(), split it into separate IPrinter, IScanner, and IFax interfaces.

5. Dependency Inversion Principle (DIP)

High-level modules should not depend on low-level modules. Both should depend on abstractions.
Use dependency injection to decouple components.

✅ Example: Instead of a Service class directly instantiating a Database, inject an IDatabase interface that different database implementations can follow.

Why SOLID Matters?

Makes code easier to maintain and extend

Reduces bugs and improves testability

Enhances collaboration in large teams

By applying SOLID, you’ll write cleaner, more efficient, and scalable software. Which of these principles do you struggle with the most? Let’s discuss in the comments!

Understanding SQL Triggers: A Developer’s Guide

Ebenezer Tosan — Mon, 24 Feb 2025 14:27:29 +0000

Introduction

SQL Triggers are a powerful feature in relational databases that allow you to automatically execute a set of SQL statements in response to specific database events. Triggers help maintain data integrity, enforce business rules, and automate tasks without requiring manual intervention.

In this article, we’ll explore what SQL Triggers are, their types, and how to implement them with practical examples.

What Are SQL Triggers?

A trigger is a special type of stored procedure that is automatically executed before or after specific database operations such as INSERT, UPDATE, or DELETE. Triggers are useful for enforcing constraints, auditing changes, and performing automatic updates.

Key Characteristics of SQL Triggers
Automatically invoked when a defined event occurs.
Can be applied to INSERT, UPDATE, and DELETE operations.
Help in enforcing business rules and maintaining data consistency.
Cannot be explicitly called like stored procedures.

Types of SQL Triggers

SQL triggers can be categorized based on when they are executed and what event they respond to.

1. Based on Execution Timing
BEFORE Trigger: Executes before the event occurs. Useful for validation.
AFTER Trigger: Executes after the event occurs. Commonly used for logging and auditing.
INSTEAD OF Trigger: Replaces the execution of the triggering event. Often used for complex views.

2. Based on Triggering Event
INSERT Trigger: Fires when a new row is inserted into the table.
UPDATE Trigger: Fires when an existing row is updated.
DELETE Trigger: Fires when a row is deleted from the table.

Implementing SQL Triggers

Let's walk through some examples using PostgreSQL and SQL Server to understand how triggers work in real-world applications.

Example 1: Creating an Audit Log Using an AFTER INSERT Trigger
Let's say we have a users table, and we want to log all new user registrations into an audit_log table.

PostgreSQL Example

`CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(100),
    email VARCHAR(150),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE audit_log (
    log_id SERIAL PRIMARY KEY,
    action TEXT,
    username VARCHAR(100),
    log_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE OR REPLACE FUNCTION log_user_insert() 
RETURNS TRIGGER AS $$
BEGIN
    INSERT INTO audit_log (action, username, log_time)
    VALUES ('User Inserted', NEW.username, NOW());
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER user_insert_trigger
AFTER INSERT ON users
FOR EACH ROW
EXECUTE FUNCTION log_user_insert();`

📌 How It Works:

The function log_user_insert() inserts an entry into audit_log when a new user is added.
The trigger user_insert_trigger calls this function after an INSERT operation on users.

When to Use SQL Triggers?

✅ Use SQL triggers when:

You need automatic auditing of database changes.
You want to enforce business rules at the database level.
You need to maintain data integrity across multiple tables.
❌ Avoid SQL triggers when:

The logic can be implemented at the application level for better performance.
They introduce hidden complexity, making debugging harder.
They cause performance issues due to excessive execution.

Conclusion

SQL triggers are a powerful tool that can help automate database tasks, enforce data integrity, and maintain logs of changes. However, they should be used wisely to avoid performance bottlenecks.

Are you using SQL triggers in your projects? Share your thoughts in the comments! 🚀

Introduction to Materialized Views in SQL for Beginners

Ebenezer Tosan — Mon, 17 Feb 2025 14:17:28 +0000

What is Materialized View?

A Materialized View in SQL is a database object that contains the results of a query stored physically. Unlike a standard view, which is a virtual table, a materialized view stores the query results on disk, making data retrieval much faster, especially for complex queries.

Why Use Materialized Views?

Materialized views are useful in scenarios where:

Query performance needs improvement by avoiding repeated complex calculations.
Pre-computed aggregated data is required for reporting.
Data needs to be refreshed periodically rather than recalculated on every request.

Creating a Materialized View

The syntax for creating a materialized view varies by database system, but the general structure is:

CREATE MATERIALIZED VIEW view_name AS SELECT column1, column2, aggregate_function(column3) FROM table_name WHERE conditions;

Refreshing a Materialized View
Since the data is stored physically, it may become outdated. Most databases allow you to refresh a materialized view manually or automatically:

REFRESH MATERIALIZED VIEW sales_summary;

Note: Some databases also support incremental refresh for efficiency.

Advantages of Materialized Views

Performance Boost: Queries execute faster as precomputed data is stored.
Reduced Load on Database: Less computation power is required for repeated queries.
Supports Aggregated Data: Ideal for dashboards and analytical reporting.

Disadvantages

Storage Overhead: Requires additional space to store results.
Needs to be Refreshed: Data can become stale and requires periodic updates.
Not Always Real-Time: Unlike normal views, data is not dynamically updated.

When to Use Materialized Views

Materialized views are best suited for:

Reporting and BI applications.
Frequently accessed, computationally expensive queries.
Pre aggregated data sets for faster analytics.

By understanding and implementing materialized views effectively, you can optimize database performance and enhance the efficiency of your SQL queries!