https://www.facebook.com/100637039200930/

Clever Engineer, 9 Street sinkor, Monrovia (2026)

18/09/2025

𝐏𝐨𝐥𝐲𝐦𝐨𝐫𝐩𝐡𝐢𝐬𝐦 𝐄𝐱𝐩𝐥𝐚𝐢𝐧𝐞𝐝

Polymorphism means “many forms.” In programming, it allows the same method name or interface to produce different behaviors depending on the object that uses it.

It helps us write flexible, reusable, and extensible code—where the general structure stays the same, but the specific behavior is decided either at compile-time or runtime.

Real-World Analogy

Think of the word “play.”

A musician plays an instrument.

A child plays with toys.

An athlete plays football.

The word “play” is the same, but its meaning changes depending on the context.
That’s polymorphism—the same action name triggers different results depending on who’s performing it.

Why Polymorphism Matters

Loose Coupling → You work with general types (interfaces or base classes) instead of specific classes.

Flexibility → You can add new behaviors without rewriting old code.

Scalability → Your system can grow to handle new cases smoothly.

Extensibility → You can “plug in” new implementations without touching the core logic.

There are three main Type of Polymorphism

REAM MORE ALSO DON't FORGET TO LIKE THIS PAGE
https://open.substack.com/pub/cleverengineer/p/polymorphism-explained?r=1nba3w&utm_campaign=post&utm_medium=web&showWelcomeOnShare=true

16/09/2025

𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲𝘀 𝗘𝘅𝗽𝗹𝗮𝗶𝗻

In object-oriented design, interfaces help us build flexible, testable, and loosely connected systems. They act like contracts: they define what must be done, but not how it should be done.

1. What is an Interface?

An interface lists method names that any class must provide.

It doesn’t care about the internal logic, only the structure.

Analogy:

Think of a remote control:

play()

pause()

volumeUp()

powerOff()

No matter if it controls a TV, a speaker, or a projector — the buttons stay the same, but the actions behind them differ.

That’s exactly how interfaces work in code.

2. Why Use Interfaces?

Define behavior, not details → They say what should happen, but not how.

Enable polymorphism → Different classes can follow the same interface in their own way.

Promote decoupling → Code depends on the interface, not the concrete class, so changes in implementation don’t break everything else.

ReadMore and don't forget to subscribe to the Clever Engineer News Letter the mission is to help 10,000 developers get better every day.

https://shorturl.at/CiHdZ

14/09/2025

𝗘𝗻𝗰𝗮𝗽𝘀𝘂𝗹𝗮𝘁𝗶𝗼𝗻 𝗘𝘅𝗽𝗹𝗮𝗶𝗻𝗲𝗱

Encapsulation is one of the core pillars of object-oriented programming (OOP). It refers to the concept of combining data (fields) and the functions that work on that data (methods) into a single unit

Real-World Analogy

Imagine a vending machine. You don’t open it up to grab snacks or fiddle with the money system inside.

Instead, you use the buttons and coin slot interface.

The machine gives you limited, predefined options: insert money, select an item, get your snack.

You never see how the inventory is tracked or how the change is calculated.

Internally, the company may redesign how the machine handles inventory or payments, but your experience as the user stays consistent.

Also don't forget to follow this page

Serious about your Software Engineering growth 👇🏾

READ MORE

https://open.substack.com/pub/cleverengineer/p/encapsulation-explained?r=1nba3w&utm_campaign=post&utm_medium=web&showWelcomeOnShare=true

09/09/2025

𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗘𝗻𝘂𝗺𝘀

Enumerations, commonly called enums, are a practical yet often overlooked feature in object-oriented programming.

𝗪𝗵𝗮𝘁 𝗘𝘅𝗮𝗰𝘁𝗹𝘆 𝗶𝘀 𝗮𝗻 𝗘𝗻𝘂𝗺?

An enum is a specialized data type that groups together a predefined list of constant values under a single label. Unlike raw integers or plain strings, enums enforce type safety — meaning you can’t assign an arbitrary value to a variable that expects a specific enum type.

Enums are most useful when a variable should only accept one choice out of a restricted set.

𝗘𝘃𝗲𝗿𝘆𝗱𝗮𝘆 𝗘𝘅𝗮𝗺𝗽𝗹𝗲𝘀 𝗼𝗳 𝗘𝗻𝘂𝗺𝘀

Payment Methods → CREDIT_CARD, PAYPAL, BANK_TRANSFER

Seasons → SPRING, SUMMER, AUTUMN, WINTER

Access Levels → GUEST, USER, MODERATOR, ADMIN

Traffic Light Signals → RED, YELLOW, GREEN

Using enums eliminates “magic values” (hardcoded strings or numbers), makes your intent clearer, gives compiler checks and IDE autocomplete support, and reduces the likelihood of accidental mistakes.

Don't forget to follow Clever Engineer

𝗥𝗘𝗔𝗗 𝗠𝗢𝗥𝗘

https://tinyurl.com/29uf8y6j

07/09/2025

Object-Oriented Programming (OOP) is a programming paradigm(pattern or style of doing thing) that organizes code around objects rather than functions. It models real-world entities as objects that contain both data (attributes) and code (methods) that operates on that data.

1. What is a Class?

A class is essentially a blueprint or template. It defines the attributes (data) and methods (behavior) that its objects will have.

Imagine you want to build several houses in an estate, and you want all of them to look alike. Instead of constructing a few houses randomly, you would first create a blueprint. This blueprint ensures that every house follows the same design.

In the same way, a Class in programming acts as a blueprint. It defines the structure and behavior that multiple Objects will share. If you want to create many objects, you first need a class to guide their creation

Key points about a class:

Groups related data and behavior together.

Attributes are represented as variables.

Methods (functions inside a class) act on that data.

2. What is an Object?

An object is an instance of a class. It takes the abstract design of a class and turns it into something concrete. Each object has its own state (its own copy of attributes) and can perform the actions defined in the class.

Want to learn coding don't forget to subscribe to The Clever Engineer Notebook

Read more
https://shorturl.at/70qQi

05/09/2025

𝐖𝐡𝐚𝐭 𝐢𝐬 𝐋𝐨𝐰-𝐋𝐞𝐯𝐞𝐥 𝐃𝐞𝐬𝐢𝐠𝐧 (𝐋𝐋𝐃)?

In software engineering, Low-Level Design (LLD) is where abstract concepts are turned into practical, working blueprints. It’s the step where a High-Level Design (HLD) is broken down into detailed class diagrams, interfaces, object relationships, and design patterns.

What LLD Really Means

LLD answers the question: “How exactly will we implement this?

HLD says: “We need a Ride-Sharing Service.”

LLD says: “We’ll create an interface RideAllocator with implementations like NearestDriverAllocator and CheapestDriverAllocator, both coordinated by a RideManager.”

LLD zooms in on the building blocks of your system. It ensures the software is modular, extendable, testable, and understandable. It’s not just about making something work—it’s about designing systems that can adapt and grow.

Core Components of LLD

1. Classes and Objects

This is where design begins: defining the key entities.

Ask yourself:

What classes represent the main concepts?

What responsibilities do they have?

What data do they hold?

What actions do they perform?

Example: In a library management system, we might define:

Book – stores title, author, and availability

Member – borrows and returns books

Librarian – manages inventory

Loan – represents the borrowing transaction

2. Interfaces and Abstractions

Interfaces define contracts between components. They ensure loose coupling so implementations can change without breaking the system.

Ask yourself:

What should a class expose to the outside?

Which details should remain hidden?

What can be abstracted behind an interface?

Example: A SearchEngine interface could have multiple implementations:

ElasticSearchEngine

SolrSearchEngine

InMemorySearchEngine

The system depends only on the SearchEngine interface, not on the concrete choice.

3. Relationships Between Classes

Classes interact with each other in structured ways. LLD defines these relationships clearly:

Association – a general “uses-a” relationship

Composition – strong “has-a” (lifespan tied)

Aggregation – weaker “has-a” (independent lifespan)

Inheritance – “is-a” relationship for shared behavior

Example:

A Library has many Books (composition).

A Member can borrow multiple Books (one-to-many).

A Librarian manages several Members (aggregation).

4. Method Signatures

Once the structure is clear, you define operations.

Ask:

What methods should each class have?

What parameters and return types are needed?

Should they be synchronous or asynchronous?

What exceptions could they throw?

Bad: void doTask(String s)Better: void borrowBook(Book book, Member member)

The improved method is clearer, domain-specific, and more extensible.

Read More here

https://url-shortener.me/47AB

01/08/2025

𝐇𝐞𝐫𝐞’𝐬 𝐚 𝐛𝐞𝐚𝐮𝐭𝐢𝐟𝐮𝐥 𝐪𝐮𝐞𝐬𝐭𝐢𝐨𝐧 𝐟𝐨𝐫 𝐲𝐨𝐮:

You are given an n x n 2D matrix representing an image. Rotate the image by 90 degrees (clockwise).

You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

Well, when I saw this question, I knew the optimal solution right out of the box because I have a bit of a mathematics background.
Transpose the matrix, then reverse it.

Transposing a matrix means making each row in the matrix its column and each column its row. It turns out there’s a constant when we transpose the matrix. Take, for example, the following matrix:

1 2 3
4 5 6
7 8 9
There’s a constant diagonal of 1, 5, 9. Let’s transpose this matrix, and I will discuss why this is, in fact, important to know:

1 4 7
2 5 8
3 6 9

If we move along this diagonal and swap opposite elements, then we have transposed the matrix: [0][1] = [1][0], [0][2] = [2][0], [1][2] = [2][1]

and the last part we can reverse every row
7 4 1
8 5 2
9 6 3

here is the question for you
https://shorturl.at/FKwBo

30/07/2025

𝐓𝐡𝐢𝐬 𝐢𝐬 𝐚 𝐛𝐞𝐚𝐮𝐭𝐢𝐟𝐮𝐥 𝐐𝐮𝐞𝐬𝐭𝐢𝐨𝐧

Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.

𝐄𝐱𝐚𝐦𝐩𝐥𝐞 𝟏:

Input: nums = [3,0,1]

Output: 2

𝐄𝐱𝐩𝐥𝐚𝐧𝐚𝐭𝐢𝐨𝐧:

n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.

𝐈𝐧𝐭𝐮𝐢𝐭𝐢𝐨𝐧

There are actually two ways to solve this problem either you use logic cancellation or the sum of real numbers.

𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡

The Approach for the sum of real number is given as follow we know that for any real number you can find the sum by saying n(n+1)/2 this is a formular in arthmentic progression if you want the sum form 1 to 5 5(5+1)/2 = 15 it equal to 1+2+3+4+5 = 15

we can compute the summation of the array and substract the actual sum form the expected sum the result is the missing number.

Complexity

Time complexity:

O(n)

Space complexity:

O(1)

𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝐍𝐮𝐦𝐛𝐞𝐫 𝟐

The second is using the theory of logic

the following are true for xor

a ^ a = 0
a ^ 0 = a

equip with this knowledge we can Try to generate two group and cancel out where needed

Group 1 , 0, 1, 2, 3 or (0 ^ 1 ^ 2 ^ 3)

Group 2, 3, 0, 1 or (3 ^ 0 ^ 1)

we can combine them

(0 ^ 1 ^ 2 ^ 3) ^ (3 ^ 0 ^ 1)

let combine like term

0 ^ 0 ^ 1 ^ 1 ^ 3 ^ 3 ^ 2 = 2

The following two solution have the same time and space complexity

The actual solution is here

https://shorturl.at/XJU06

Remember it good to be smart but what even better is being consistent. Stay humble stay loyal to your grind

30/09/2024

Try out our new Mobile app that help smoothing payment of Events

Version with updated instructions

Join the Tick8 Plus Beta Testing Program!

We’re excited to announce the beta testing program for Tick8 Plus, the cashless event ticketing platform developed by BITS. We seek feedback from passionate users to help us improve the attendee and organizer mobile apps. Testing is currently limited to Android (APK), and your feedback will be invaluable in shaping the final version of our platform.

By joining, you’ll be among the first to experience Tick8 Plus' seamless ticket purchasing, NFC-based in-event transactions(excluded from this initial test), and more! Your honest and logical feedback will help us deliver the best possible product.

How It Works:

Sign Up: We collect your name and email to have a record of all testers.
Anonymous Feedback: To ensure feedback remains unbiased, it will be stored separately from your details, keeping it anonymous.
If you’re interested in being part of our journey and providing valuable insights, please visit our beta program page below:

👉 Join the Tick8 Plus Beta Program (https://www.tick8plus.com/ -program)

We look forward to your participation and thank you for helping us make Tick8 Plus better!

Something to note:
In the attendee app, currently, all payments are in the demo stage, so there no actual deduction will be made.

For stripe payment, you can use the following test details
Card number:
424242424242424242 - expiry:
04/26 | cvv: 424

MTN Momo: any valid 10 digit (0880112233)

Wallet: To use the wallet method as payment, you need to firstly access the wallet screen and top up your wallet using mtn momo (0880112233). Then, you can test the wallet payment feature...

For organizer: The available amount to withdraw will only show after your event has ended. Once your available amount to withdraw is available, you can withdraw using MTN Momo(only for now)Try this new platform

04/02/2024

🚀 𝗨𝗻𝗹𝗼𝗰𝗸𝗶𝗻𝗴 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝗥𝗲𝗹𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆: 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗔𝗖𝗜𝗗 𝗣𝗿𝗼𝗽𝗲𝗿𝘁𝗶𝗲𝘀 🚀

Ever wondered how databases ensure the reliability and integrity of your data, especially in critical applications like banking and healthcare? Let's delve into the world of ACID properties – the backbone of database transactions!

𝟭͟.͟ ͟𝗪͟𝗵͟𝗮͟𝘁͟ ͟𝗶͟𝘀͟ ͟𝗔͟𝗖͟𝗜͟𝗗͟ ͟𝗣͟𝗿͟𝗼͟𝗽͟𝗲͟𝗿͟𝘁͟𝘆͟ ͟𝗼͟𝗳͟ ͟𝗗͟𝗮͟𝘁͟𝗮͟𝗯͟𝗮͟𝘀͟𝗲͟:͟

ACID is like a set of rules that databases follow to make sure they handle data reliably and safely. It stands for:

𝗔𝘁𝗼𝗺𝗶𝗰𝗶𝘁𝘆: Treats a set of operations as one whole thing. Either all of them happen, or none of them.

Description:

Start Transaction:

The transaction begins.
Execute Operations: Multiple operations are executed as part of the transaction.

Checkpoint:
A checkpoint is reached. At this point, the system ensures that all operations have been completed successfully.

Commit:
If all operations succeed, the changes are committed to the database. If any operation fails, a rollback is performed, and the changes are discarded.

𝗖𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝘆: Makes sure that the database is in a valid state before and after transactions.

Description:
Start Transaction:
The transaction begins.

Execute Operations:
Multiple operations are executed as part of the transaction.

Consistency Check:
After each operation, a consistency check is performed to ensure that the database remains in a consistent state.

Commit:
If the consistency check passes for all operations, the changes are committed to the database. If any consistency check fails, a rollback is performed

𝗜𝘀𝗼𝗹𝗮𝘁𝗶𝗼𝗻: Keeps different transactions separate, so they don't interfere with each other.

Description:
Start Transaction (T1): Transaction T1 begins.
Start Transaction (T2): Concurrently, another transaction T2 begins.

Execute Operations (T1 and T2): Both transactions execute their respective operations concurrently.
Isolation: The operations of each transaction are isolated from each other, and neither is aware of the other's changes until they are committed.

Commit (T1 and T2): Each transaction independently commits its changes to the database.

𝗗𝘂𝗿𝗮𝗯𝗶𝗹𝗶𝘁𝘆: Once a transaction is complete, its changes are permanent, even if something goes wrong.

Description:
Commit: The transaction commits its changes to the database.

Write to Log: The committed changes are written to a transaction log or journal.
Checkpoint: Periodically, the system creates a checkpoint, ensuring that all committed changes are permanently stored.

Recovery: In the event of a failure, the system can use the transaction log to recover the database to its last consistent state.

Imagine ACID like baking a cake. You want all the ingredients mixed (atomicity), the cake to taste good (consistency), each step to be done without messing with other recipes (isolation), and once it's baked, it stays baked (durability).

Please give us a follow if you love this
Clever Engineer

03/02/2024

𝗥𝗘𝗦𝗧 𝗔𝗣𝗜𝘀: 𝗧𝗵𝗲 𝗖𝗼𝗻𝗲𝗿𝘀𝘁𝗼𝗻𝗲 𝗼𝗳 𝗠𝗼𝗱𝗲𝗿𝗻 𝗪𝗲𝗯 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁

As a software engineer, I've always been passionate about sharing my knowledge and simplifying complex technical concepts. This presentation on REST APIs aims to provide a comprehensive understanding

Let's dive into the world of REST APIs with an analogy that might resonate.

Think of a REST API as a waiter at a restaurant. You, the client (or in API terms, the user), sit at the table (your device) and request a menu (data). The waiter (REST API) takes your order (request) to the kitchen (server), and soon enough, your dish (response) arrives.

Now, just like a restaurant has various actions – ordering, updating preferences, or even canceling an order – a REST API has different methods:

𝗚𝗘𝗧: Fetches specific data.
𝗣𝗢𝗦𝗧: Adds new data.
𝗣𝗨𝗧: Updates existing data.
𝐃𝐄𝐋𝐄𝐓𝐄: Removes specific data.
𝗣𝗔𝗧𝗖𝗛: Makes partial updates.

Responses from the API are like the waiter's service – either successful (your order is delivered) or an error (oops, kitchen couldn't handle it).

Understanding this helps whether you're into software or just curious about how things online work together. I made this simple presentation to break down the basics of REST APIs. If you're diving into tech or just want to know more, I'm here to help. Expect more easy-to-understand stuff from me in the future! Got questions or thoughts? Let's chats

also if you like what we are doing you can follow us here on Facebook Clever Engineer

01/02/2024

𝐈𝐧 𝐬𝐲𝐬𝐭𝐞𝐦 𝐝𝐞𝐬𝐢𝐠𝐧 𝐈𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰𝐬 𝐲𝐨𝐮 𝐰𝐢𝐥𝐥 𝐛𝐞 𝐚𝐬𝐤 𝐭𝐡𝐢𝐬 𝐪𝐮𝐞𝐬𝐭𝐢𝐨𝐧 𝐭𝐨 𝐝𝐞𝐬𝐢𝐠𝐧 𝐚 𝐫𝐚𝐭𝐞 𝐥𝐢𝐦𝐢𝐭𝐞𝐫

A rate limiter serves as a throttle for API endpoints, defining the allowable frequency of API calls within a specified time interval.

𝑊ℎ𝑦 𝑖𝑠 𝑎 𝑟𝑎𝑡𝑒 𝑙𝑖𝑚𝑖𝑡𝑒𝑟 𝑐𝑟𝑢𝑐𝑖𝑎𝑙?

It safeguards against potential DOS attacks on APIs and, additionally,

It also curtails costs by processing only those requests that need to be executed within a designated time frame.

When crafting a rate limiter, it's crucial to weigh where to implement it—whether on the client side, server side, or within middleware. The choice depends entirely on the specific problem you are addressing. But the recommend best place is the server

Here are various types of rate limiter algorithms to consider:

𝐓𝐨𝐤𝐞𝐧 𝐁𝐮𝐜𝐤𝐞𝐭 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦
𝐋𝐞𝐚𝐤𝐲 𝐁𝐮𝐜𝐤𝐞𝐭 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦
𝐅𝐢𝐱𝐞𝐝 𝐖𝐢𝐧𝐝𝐨𝐰 𝐂𝐨𝐮𝐧𝐭𝐞𝐫
𝐒𝐥𝐢𝐝𝐢𝐧𝐠 𝐖𝐢𝐧𝐝𝐨𝐰 𝐂𝐨𝐮𝐧𝐭𝐞𝐫
𝐃𝐢𝐬𝐭𝐫𝐢𝐛𝐮𝐭𝐞𝐝 𝐑𝐚𝐭𝐞 𝐋𝐢𝐦𝐢𝐭𝐢𝐧𝐠

𝗧𝗼𝗸𝗲𝗻 𝗕𝘂𝗰𝗸𝗲𝘁 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺

Maintain a bucket with tokens, each representing the right to make an API call.
Tokens are added to the bucket at a fixed rate.
When an API call is made, a token is consumed from the bucket.
If the bucket is empty, further API calls are delayed until tokens are replenished.

𝗟𝗲𝗮𝗸𝘆 𝗕𝘂𝗰𝗸𝗲𝘁 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺

Conceptually, requests "leak" into a bucket at a fixed rate.
When a request arrives, it is placed in the bucket.
If the bucket is full, excess requests are discarded or delayed.
Requests are processed at a constant rate, preventing bursts of traffic.

𝗙𝗶𝘅 𝘄𝗶𝗻𝗱𝗼𝘄

Maintain a counter for each fixed time window.
Increment the counter for each API call within the window.
Reset the counter at the end of the window.
Limit the total count within the window to control the rate.

𝗦𝗹𝗶𝗱𝗶𝗻𝗴 𝗪𝗶𝗻𝗱𝗼𝘄 𝗖𝗼𝘂𝗻𝘁𝗲𝗿

Similar to the fixed window counter, but the time window "slides" continuously.
Track the count of API calls within the most recent time interval.
Enforce a limit on the total count within the sliding window.

𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗥𝗮𝘁𝗲 𝗟𝗶𝗺𝗶𝘁𝗶𝗻𝗴

Use multiple rate limiters distributed across different components or servers.
Centralized coordination or distributed algorithms ensure a global rate limit is maintained.
Effective for large-scale systems to prevent overloads and ensure fair resource allocation.

Each algorithm provides a different approach to controlling the rate of API requests, allowing system designers to choose based on specific requirements and characteristics of their applications.

Follow Clever Engineer for more quality tech knowledge

Clever Engineer

18/09/2025

16/09/2025

14/09/2025

09/09/2025

07/09/2025

05/09/2025

01/08/2025

30/07/2025

30/09/2024

04/02/2024

03/02/2024

01/02/2024

Address

Telephone

Website

Alerts

Shortcuts

Share

Category

Listing takedown request