Forem: MegaWatts

Overcoming Challenges

MegaWatts — Sun, 30 Jun 2024 00:22:06 +0000

Solving complex problems is more than just a technical challenge; it’s a journey of continuous learning and growth. As a growing backend developer, I’ve always been driven by the desire to develop efficient, scalable, and maintainable server-side logic. Recently, I faced a challenge that tested my skills, thought process, and determination.

I was tasked with optimizing the business logic at the server-side for an equipment management system. Equipment are to be serviced based on data from different components of the equipment inputted by the user. Initially, the criteria for servicing an equipment were based on the engine and tire components. Management decided to add another criterion for servicing, which added to the complexity of the system.

At that time, the existing implementation of the logic wasn’t up to par. It lacked reusability, separation of concerns, and was difficult to understand. Here are the steps I took to solve the challenge:

Understand the Requirements
Before diving into coding, I made a concerted effort to understand the requirements of the system. This included:

The functionality the system needs to provide.
The various modules or components required.
How these components will interact with each other.

Identify Core Components
I identified the core components of the system. An equipment was modeled as a class using other components like engine, tire, and fuel consumption properties. Each component represented a distinct part of the functionality:

Equipment Management
Component Management
Service Management
A UML Class Diagram to state the relationships between classes was created.

Define Responsibilities Clearly
Each class was designed to have a single responsibility. This approach makes classes easier to understand, maintain, and reuse. For example:

The Equipment class handles general equipment details.
The Engine class manages engine-specific properties and behaviors.
The ServiceManager class handles the logic for determining when an equipment needs servicing.

Use Interfaces and Abstract Classes
Interfaces and abstract classes help in defining contracts and promoting code reuse. I used them to outline the basic structure and functionality that concrete classes should implement.

python

from abc import ABC, abstractmethod

class Component(ABC):
    @abstractmethod
    def needs_service(self) -> bool:
        pass

Implement Concrete Classes
I implemented the concrete classes that adhere to the interfaces or extend the abstract classes. This ensures that the classes are consistent and reusable.

python

class Engine(Component):
    def __init__(self, hours_run: int):
        self.hours_run = hours_run

    def needs_service(self) -> bool:
        return self.hours_run > 1000

class Tire(Component):
    def __init__(self, wear_level: float):
        self.wear_level = wear_level

    def needs_service(self) -> bool:
        return self.wear_level > 0.8

Use Design Patterns
I studied and implemented design patterns to promote reusability and simplicity. Using the Factory pattern, I was able to produce reusable and simple components.

python

class ComponentFactory:
    @staticmethod
    def create_component(component_type: str, **kwargs) -> Component:
        if component_type == "engine":
            return Engine(**kwargs)
        elif component_type == "tire":
            return Tire(**kwargs)
        else:
            raise ValueError("Unknown component type")

Keep It Simple
I adhered to the KISS principle by ensuring each class does one thing and does it well. This made the codebase easier to understand and maintain.

Write Tests
I wrote unit tests for each class to ensure they work as expected. This also makes future changes easier and safer.

python

import unittest

class TestEngine(unittest.TestCase):
    def test_needs_service(self):
        engine = Engine(hours_run=1200)
        self.assertTrue(engine.needs_service())

if __name__ == "__main__":
    unittest.main()

By following these steps, I was able to create classes that adhere to the KISS principle, making the codebase easier to maintain and extend. The result of refactoring the code was a dramatic improvement in the application's design. It became easy to understand, maintain, and extend. This experience not only solved a critical problem but also deepened my understanding of software design principles.

The HNG Internship is a fast-paced boot camp for learning digital skills, and being part of it means being surrounded by a community of like-minded individuals who are equally passionate about technology.

My journey with HNG started with a simple desire to improve my skills. The opportunity to work on real-world projects, collaborate with talented developers, and receive mentorship from industry experts is invaluable.

HNG Hire makes it easy to find and hire elite talent.

First glance - Sales Dataset

MegaWatts — Sat, 29 Jun 2024 23:00:03 +0000

Introduction

The sales dataset is a collection of orders made by different customers from various geographical are[CITY,STATE,POSTALCODE,COUNTRY]. Each entry includes detailed information about the customer [CUSTOMERNAME, CONTACTLASTNAME CONTACTFIRSTNAME], the order [ORDERNUMBER, DATE, STATUS], and the products ordered [PRODUCTLINE, MSRP, PRODUCTCODE]. This dataset spans from 2003 to 2005 and includes contact person information.

Each entry contains an order number[ORDERNUMBER] which represents a unique identifier for each order. An order entry contains different products [PRODUCTCODE] associated with a product line [PRODUCTLINE].
Data columns such as deal size [DEALSIZE] and status [STATUS] are used to categorize different products. The dataset includes pricing [PRICEEACH], quantity ordered [QUANTITYORDERED], and the total sales amount [SALES].

The dataset contains 2823 entries of orders with 25 data columns, of which 9 are numerical and 3 are categorical data [STATUS, DEALSIZE, PRODUCTLINE].

Fig. 1 showing retail sales data dataset's main statistical properties

Key Components of the Dataset:

Customer Information: [CUSTOMERNAME, CONTACTLASTNAME, CONTACTFIRSTNAME, PHONE]
Geographical Information: [ADDRESSLINE1, ADDRESSLINE2, CITY, STATE, POSTALCODE, COUNTRY, TERRITORY]
Order Information: [ORDERNUMBER, ORDERDATE, STATUS]
Product Information: [PRODUCTLINE, PRODUCTCODE, QUANTITYORDERED, PRICEEACH, SALES]
• Additional Attributes: [QTR_ID, MONTH_ID, YEAR_ID, MSRP, DEALSIZE]

Fig 2 shows the shape of the retail sales data

Purpose of the Review
The purpose of this review is to provide an initial understanding of the dataset's structure, content, and data quality. This will help to:

Detect missing values and assess their impact.
Identify necessary data type conversions for accurate analysis.
Determine important columns for analysis such as sales figures, order details, and customer information.

Observations

Multiple Products per Order: An ORDERNUMBER may be associated with more than one product [PRODUCTCODE] from different product lines [PRODUCTLINE].
Sales Calculation Discrepancy: The [SALES] column is not always the multiplication of the [QUANTITYORDERED]and [PRICEEACH] columns. There are 1304 entries that do not follow this calculation.
Order Date Format: The [ORDERDATE] is in object format and will need to be converted to a datetime format for any time series analysis.
Inconsistent Phone Data: The [PHONE] data does not follow a consistent pattern across different countries.

Potential Areas for Further Analysis:

Sales Performance:
- Analyze completed sales data over time, by product, and by region.
- Analyze sales data based on status by product, region, and time.
Customer Insights:
- Segment customers and analyze their purchasing behavior.
Geographical Insights:
- Map sales data and customer locations.
Forecasting:
- Predict quantity and product sales for the next year.

I am currently an intern in the HNG Internship boot camp that builds apps and solves different problems in teams. The HNG Internship is a fast-paced boot camp for learning digital skills. HNG Hire makes it easy to find and hire elite talent.