DEV Community: BiKodes

How Pseudocode Programming Process Leveled Up My Software Engineering Skills

BiKodes — Sat, 02 Aug 2025 14:44:49 +0000

As I continue my journey to become a better software craftsman, two insights from Martin Fowler and Uncle Bob stand out:

Martin Fowler (Refactoring)

"Any fool can write code that a computer can understand. Good programmers write code that humans can understand."

Code is a shared language. Polishing interfaces, refining layout, and writing clear comments make our intent obvious and our logic approachable.

Uncle Bob (Clean Code)

"The only valid measurement of code quality is how easily it can be understood and changed."

Clean code isn’t just functional, it’s adaptable. Applying PPP, auditing variables, and keeping routines focused all strengthen a codebase.

Their principles echo McConnell’s advice, writing code is half the job; crafting clear, human-friendly software is what makes us true craftsmen.

In 2023, shortly after joining Savannah Informatics, I had one of those pivotal moments in my software engineering journey. We were in a review session where an RFC Stephen Mwangi, my tech lead at the time, and I had worked on, and arguably the best I’ve ever had, was being examined by Dr. Ngure Nyanga. During the review, Dr. Ngure mentioned the importance of applying the Pseudocode Programming Process (PPP) in our workflow.

I remember sitting there, nodding along, but deep down, I had to admit, I didn’t know what PPP meant in practice. This was surprising even to me because I had read "Code Complete" by Steve McConnell, a book hailed as a software development classic. That review was the spark I needed. Determined to understand it better, I revisited the book with fresh eyes.

Fast forward a few years into my engineering career, with more real-world experience under my belt, I read "Code Complete" again. This time, the insights felt even sharper, almost pristine, as if McConnell had written them specifically for the problems I was facing in day-to-day development.

The Beauty of Cleaning Up Code "Leftovers"

One concept that stuck with me is McConnell’s section on "Cleaning Up Leftovers." He explains that finishing a feature or routine isn’t just about making it work; it’s about polishing it so it meets the highest standards of quality. He outlines a series of checks that serve as a final pass over your code, almost like a craftsman sanding and refining their work until it gleams.

Here are the key takeaways, simplified and rephrased:

1. Validate the Routine’s Interface

Make sure your routine handles all expected inputs and outputs correctly. Every parameter should serve a purpose. Nothing unused should sneak in, and nothing vital should be missing. It’s amazing how often overlooked parameters become silent bugs waiting to happen.

2. Confirm Design Quality

Ask yourself:

(a) Does this routine do one thing and do it well?

(b) Is it loosely coupled to the rest of the codebase?

If the answer isn’t a clear “yes,” it’s time to refactor.

3. Audit Your Variables

Look closely at variable names. Are they clear and descriptive, or cryptic and misleading? Check for unused objects, improper initialization, or anything that might confuse the next person (or future you). Clean variable hygiene leads to maintainable code.

4. Scrutinize Logic and Flow

This is where you catch the tricky stuff, off-by-one errors, infinite loops, improper nesting, or resource leaks. These logical gremlins often hide in plain sight until you zoom in on the structure.

5. Refine Layout and Readability

White space isn’t wasted space; it’s a tool. Well-placed line breaks and clear formatting make your code instantly more approachable. A properly laid-out routine guides the reader naturally through its flow.

6. Align Comments with Reality

Code evolves, and comments can become outdated. McConnell suggests reviewing the pseudocode (or design comments) that guided the implementation. Are they still accurate? Do they clearly explain why a block of code exists, not just what it does?

And here’s the kicker, if a comment simply repeats what the code says in plain sight, delete it. Redundant comments add clutter rather than clarity.

Why This Still Matters Today

Re-reading this section years later reminded me that writing code is only half the job. The other half is communication with our future selves, our teammates, and even the systems we build upon. The Pseudocode Programming Process (PPP) emphasizes thinking before coding, structuring logic in plain language first, and then translating it into clean, expressive code.

This approach not only prevents messy logic but also forces you to think about clarity from the very start. It’s a mindset shift, from “get it done” to “get it done right.”

In hindsight, that review session with Dr. Ngure was more than just feedback on an RFC; it was a reminder of what separates good engineers from great ones.

Great engineers don’t just write code that works; they leave behind code that’s readable, maintainable, and self-explanatory.

The next time you finish coding a feature, don’t stop at “it runs.” Walk through McConnell’s cleanup steps. Check your interfaces, audit your variables, refine your layout, and align your comments. You’ll be surprised how often that final polish transforms good code into truly excellent code.

Essential Bash/Shell Commands for Beginners

BiKodes — Sat, 14 Jun 2025 14:15:50 +0000

Whether you're a developer, a student, or just curious about the command line, these basic Bash and Shell commands will help you navigate and manage files more efficiently.

TIPS

1. It’s recommended to add a space between commands and symbols, e.g.,cd .., not cd...

2. Some commands might not work in Windows PowerShell but will function in the Git Bash terminal, and vice versa. Always test in your preferred setup terminal.

File and Directory Navigation

ls

Lists all files and folders in the current directory.

ls <folder_name>

Displays all contents inside a specific folder.

cd ..

Moves up to the parent directory.

cd <folder_name>

Navigates to a specific folder. Use quotes if the folder name contains spaces, e.g., cd "My Documents".

pwd

Prints the current working directory path.

start . (Windows) or open . (Mac)

Opens the current folder in your default file explorer.

Creating Files and Folders

mkdir <folder_name>

Creates a new folder.

touch <file_name>

Creates a new file (with or without an extension), e.g., touch notes.txt.

Deleting Files and Folders

rm <file_name>

Deletes a file permanently (use with caution!).

rmdir <folder_name>

Deletes an empty folder.

⚠️ To delete a folder with contents, use rm -r <folder_name>.

System Operations

<drive_letter>: (Windows only)

Switches to a different disk drive, e.g., E: or D:.

ren <old_name> <new_name>

Renames a file or folder.

systeminfo (Windows only)

Displays detailed system information.

shutdown /s (Windows only)

Shuts down the system after a set time or immediately.

shutdown /l (Windows only)

Logs out of the current user session.

Command Management

command1 & command2

Runs multiple commands sequentially.

cls (Windows) or clear (Unix/Linux/macOS)

Clears the terminal screen.

exit

Closes the terminal session.

Final Tips

Begin your journey by reading Linux for Beginners: An Introduction to the Linux Operating System and Command Line, a great starting point for anyone new to Linux and the command line.
Practice these commands in a Git Bash terminal or Linux shell to get comfortable.
Always double-check before using destructive commands, such as rm.

Got questions or want to explore advanced Bash scripting? Let us know in the comments or reach out on GitHub! Happy hacking!

How to Optimize SQL Queries for Speed and Efficiency

BiKodes — Mon, 31 Mar 2025 19:29:35 +0000

Efficient SQL performance is essential for fast data retrieval and reducing system load. The following tips provide practical strategies, from proper indexing to analyzing execution plans to optimize your queries and boost overall performance.

Here are a few simple things you should know before reading this article.

1. Basic SQL Skills
You should know how to write basic SQL commands like SELECT, WHERE, and JOIN.

2. Database Basics
Understand what a database is, how data is stored in tables, and what indexes and keys do.

3. Common Performance Issues
Be aware that slow queries can happen because of full table scans, bad joins, or heavy sorting.

4. Reading Query Plans
It helps if you know how to use tools like **EXPLAIN **to check how your queries run and find bottlenecks.

5. Interest in Faster Queries
If you want to learn how to make your SQL queries run faster and use fewer resources, this article will be very useful.

It's important to remember that while the basics of SQL are similar across different databases, the way each one processes queries can be different. Databases like MySQL, PostgreSQL, SQL Server, and Oracle each use their query optimizers to determine the best way to run queries. These optimizers are built to match the unique design and features of each system. Because of this, the tips shared in this article might not work the same way on every database.

Proper Indexing
One key to speeding up SQL queries is proper indexing. Ensure that indexes are created on columns frequently used in WHERE clauses or JOIN conditions. This can drastically reduce data retrieval time, especially in large tables.

Indexing allows the database to locate and retrieve data quickly without scanning the entire table.

Example
If you frequently filter or join on the last_name column in a customer's table, create an index.

-- Create an index on last_name
CREATE INDEX idx_customers_last_name ON customers(last_name);

-- Query that benefits from the index
SELECT * FROM customers WHERE last_name = 'Bikodes';

Select Only the Columns You Need
Instead of using SELECT *, explicitly list only the required columns. This reduces the amount of data processed and improves performance.

Bad Practice (fetches unnecessary data)

SELECT * FROM employees WHERE department_id = 10;

Good Practice(fetches only what's needed)

SELECT employee_id, first_name, last_name FROM employees WHERE department_id = 10;

Avoid Using the HAVING Clause When Possible
Use the WHERE clause to filter rows before aggregation. The HAVING clause should be used only for filtering grouped data, as it adds unnecessary computation if misused.

Bad Practice

SELECT department_id, COUNT(*) 
FROM employees
GROUP BY department_id
HAVING department_id = 10;

Good Practice

SELECT department_id, COUNT(*) 
FROM employees
WHERE department_id = 10
GROUP BY department_id;

Eliminate Unnecessary DISTINCT Conditions
The DISTINCT keyword forces the database engine to perform extra sorting and comparisons. Use it only when you need to remove duplicates.

Bad Practice

SELECT DISTINCT customer_id FROM orders WHERE status = 'processed';

Good Practice (if customer_id is already unique for this condition)

SELECT customer_id FROM orders WHERE status = 'processed';

Un-nest Subqueries
Replace nested subqueries with JOIN or Common Table Expressions (CTEs) to prevent repeated execution of the same query logic, reducing the processing load.

Bad Practice(subquery)

SELECT customer_name 
FROM customers 
WHERE customer_id IN (SELECT customer_id FROM orders WHERE status = 'pending');

Good Practice (using JOIN)

SELECT DISTINCT c.customer_name
FROM customers c
JOIN orders o ON c.customer_id = o.customer_id
WHERE o.status = 'pending';

Use IN Predicates on Indexed Columns
When filtering against multiple values, use the IN predicate on indexed columns to take advantage of efficient index lookups.

Example

SELECT * FROM products WHERE category_id IN (1, 2, 3, 4);

If category_id is indexed, this query will run faster.

Prefer EXISTS Over DISTINCT in One-to-Many Joins
In scenarios involving one-to-many relationships, using EXISTS can be more efficient than DISTINCT because EXISTS stops evaluating once a match is found.

Bad Practice (using DISTINCT)

SELECT DISTINCT c.customer_id 
FROM customers c
JOIN orders o ON c.customer_id = o.customer_id;

Good Practice (using EXISTS)

SELECT c.customer_id 
FROM customers c
WHERE EXISTS (
    SELECT 1 FROM orders o WHERE o.customer_id = c.customer_id
);

Use UNION ALL Instead of UNION
If duplicate elimination is not required, use UNION ALL instead of UNION. UNION forces the database to sort and remove duplicates, which can be costly.

Example

SELECT customer_id FROM customers_kenya
UNION ALL
SELECT customer_id FROM customers_tanzania;

Avoid Using OR in Join Conditions
OR Conditions in joins can prevent indexes from being used efficiently. Consider refactoring your query or breaking it into multiple queries combined UNION for better performance.

Bad Practice

SELECT * FROM employees e
JOIN departments d ON e.dept_id = d.id OR e.manager_id = d.manager_id;

Good Practice

SELECT * FROM employees e
JOIN departments d ON e.dept_id = d.id
UNION ALL
SELECT * FROM employees e
JOIN departments d ON e.manager_id = d.manager_id;

Avoid Functions on the Right-Hand Side of Comparisons
Applying functions to columns in the WHERE clause can prevent index usage. Instead, restructure your query so that the indexed columns remain untouched.

Bad Practice

SELECT * FROM orders WHERE YEAR(order_date) = 2024;

Good Practice

SELECT * FROM orders 
WHERE order_date >= '2024-01-01' AND order_date < '2025-01-01';

Eliminate Redundant Mathematical Operations
Remove unnecessary calculations from your queries. Precompute values when possible to reduce computational overhead during query execution.

Bad Practice

SELECT * FROM invoices WHERE amount * 1.18 > 1000;

Good Practice

SELECT * FROM invoices WHERE amount > 1000 / 1.18;

Learn to Read Query Execution Plans
One of the most effective ways to optimize queries is by analyzing execution plans. Understanding query plans helps you identify slow operations, such as full table scans, expensive sorts, or improper indexing, allowing you to make data-driven optimizations.

Example

You can use EXPLAIN or EXPLAIN ANALYZE to understand how queries are executed.

EXPLAIN ANALYZE
SELECT * FROM orders WHERE customer_id = 1001;

When you run a query with EXPLAIN (or EXPLAIN ANALYZE), the database shows you how it plans to execute the query. When a developer or a database administrator understands the steps involved, it helps them to spot performance issues and optimize them.

A developer or database administrator should look for the following in execution plans.

Seq Scan (Sequential Scan)

This means the database reads every row in a table to find the rows that match your query condition. Seq scan is inefficient for large tables because it doesn't use indexes. This often suggests missing or unused indexes on the filtered column.

Seq Scan on orders  (cost=0.00..431.00 rows=100 width=...

Index Scan (or Index Seek in some databases)

This means the database uses an index to find rows, making data retrieval faster. It only looks at relevant rows instead of scanning the whole table. This is typically optimal, especially for highly selective queries(queries that return a small subset of data).

Index Scan using idx_orders_customer_id on orders  (cost=0.42..8.44 rows=5 width=...)

High-cost operations (Sort, Hash Join, etc.)

When you execute a query, certain operations in your query plan can be expensive, slowing down query performance. It would be great to look for them and assess if they can be avoided or optimized

These optimization techniques can significantly improve your SQL performance. For further insights, please refer to the research paper:

Query Optimization Techniques Tips For Writing Efficient And Faster SQL Queries

Software Testing Basics

BiKodes — Sun, 10 Mar 2024 16:11:10 +0000

Testing is crucial in software development to verify applications operate as expected, meet requirements, and run reliably.

The key testing methods are:

These approaches play a crucial role in ensuring the quality and reliability of various systems and applications. Understanding and implementing these methods is essential for developers, quality assurance teams, and anyone involved in the software development lifecycle.

Each testing method serves a unique purpose, contributing to the overall goal of delivering high-performance, error-free software products.

1. Unit Testing

It validates individual code components in isolation to ensure they function properly.

2. Integration Testing

It verifies that different system components and modules interconnect and interact correctly.

3. System Testing

It evaluates the complete system against business and technical requirements. Confirms overall system functionality.

4. Load Testing

It examines system performance under anticipated peak usage levels to uncover bottlenecks.

5. Error Testing

It deliberately inputs invalid data to verify appropriate error handling and recovery.

6. Test Automation

It uses scripts to automate execution of test suites. Improves efficiency, consistency, and coverage.

It's your turn:

- How do you test your software functionality?.

- Do you highlight specific testing methods or areas of focus?.

How To Uninstall Docker and Docker Compose On Linux Mint

BiKodes — Sun, 03 Mar 2024 14:16:43 +0000

Step 1: Remove Docker Packages

Open a terminal and run the following command to list all installed Docker packages:

$ dpkg -l | grep -i docker

This will show you a list of Docker-related packages installed on your system. Thereafter you can use the following command to remove those packages:

$ sudo apt-get purge -y docker-engine docker docker.io docker-ce docker-ce-cli

Step 2: Remove Docker Images, Containers, and Volumes

You must comprehend that removing Docker packages doesn't remove your Docker images, containers, and volumes. Therefore if you want to completely remove Docker, including all its data, run the following commands:

Caution: This will delete all your Docker data, including containers, images, and volumes. Make sure you have backed up any necessary data.

$ sudo rm -rf /var/lib/docker

Step 3: Remove Docker Compose

If you have Docker Compose installed, you may want to remove it as well. Use the following command:

$ sudo rm /usr/local/bin/docker-compose

Step 4: Remove Docker Group

By default, Docker adds your user to the "docker" group. If you want to remove this group, run the following command:

$ sudo groupdel docker

Step 5: Verify Uninstallation

You can check if Docker has been completely removed by running the following command:

$ docker --version

If Docker has been successfully uninstalled, this command should return a "command not found" or No such file or directory message.

That's it! Docker should now be uninstalled from your Linux Mint system.

How To Improve API Performance

BiKodes — Wed, 28 Feb 2024 08:33:57 +0000

In the current rapidly evolving realm of software development, optimizing APIs (Application Programming Interfaces) performance is a critical endeavor to ensure seamless interactions between applications and systems. As digital ecosystems expand and user expectations evolve, the efficiency of Application Programming Interfaces (APIs) becomes essential for delivering exceptional user experiences and maintaining competitive edge in today's dynamic market.

Derived from my practical experience, the following outlines several methods that a software developer can employ to enhance the performance of their APIs.

1. Pagination

Pagination is a common optimization technique when result sets are large. By streaming results back to the client in pages, service responsiveness can be improved.

2. Asynchronous Logging

Synchronous logging writes to disk on every API call, slowing down the system. However, asynchronous logging logs are first sent to a lock-free buffer and control is immediately returned. The buffer contents are then flushed periodically to disk, significantly reducing I/O overhead.

3. Caching

Frequently accessed data can be cached for fast retrieval. Clients can query the cache first instead of hitting the database directly every time. For cache misses, the database can be queried as a fallback. In-memory caches like Redis provide faster data access compared to databases.

4. Payload Compression

Compressing API payloads can improve an application's performance and reduce bandwidth consumption by sending and receiving smaller payloads.

Request and response payloads can be compressed using algorithms such as _gzip _to reduce transmitted data volume. This speeds up upload and download times.

5. Connection Pooling

Database connection pooling is a method used to keep database connections open so they can be reused by others.

Typically, opening a database connection is an expensive operation or rather has a significant overhead, especially if the database is remote. This is due to the fact that you have to open up network sessions, authenticate, have authorization checked, and so on.

Pooling keeps the connections active so that, when a connection is later requested, one of the active ones is used in preference to having to create another one. The connection pool manages lifecycle events internally.

6. Minimize Network Round Trips

Round trip time (RTT) measures the time it takes for the data to leave a starting point (the browser) and return to that very same point in milliseconds. This is a key metric used to measure network latency, page loading times, and the overall quality of a network.

Minimization of network round trips can be achieved by batching requests whenever possible. It reduces latency and improves overall API performance.

For every query issued by the application, time is needed to reach the SQL Server and then the time needed for results to get back to the application. As all communication between an application and SQL Server goes via some network (LAN or WAN), network performance could be a critical factor affecting overall API performance. Two factors affect network performance: latency and throughput.

The latency or so-called SQL Server round-trip time (RTT) is something that is often overlooked by DBAs and database developers, but excessive round-trip time can severely affect performance.

Nevertheless, there is a bone of contention regarding pagination among some software developers. They argue that, instead of employing traditional paging techniques, it is more efficient to send an initial set of results, typically denoted as n, and indicate the presence of additional results. This approach is favored because counting all results can be time-consuming. Furthermore, proponents of this method assert that end users seldom navigate beyond the first page, providing rationale for their stance.

What other performance optimization tricks have you found useful for APIs?

What’s the most important part of Event-Driven Architecture?

BiKodes — Wed, 21 Feb 2024 06:25:26 +0000

Events are the most important part of Event Driven Architecture(EDA).

In application that has the implementation EDA, different components communicate by sending and receiving events.

But what exactly is an event?

In simple terms this is something that has occurred.

However, in detail it is a significant occurrence or happening within a system or a domain that is of interest to the participants in the system. Moreover, events can represent a wide range of activities, changes, or notifications that have an impact on the state of the system. These events are often used to trigger or communicate between different components or services in a decoupled and asynchronous manner.

Examples:

A customer signing up for your application
A payment is received for an order
A failed authentication attempt
A transaction completed
Account balance updated
A user logged in
A post published

There are mainly three different patterns I have come across while dealing with events.

- Event Notifications
- Event-Based State Transfer
- Event Sourcing

[1] Event Notifications

In this case, the event just notifies that something has occurred.

The event carries the absolute minimum state. For example, just the ID of an entity like a new order. Minimal data is sent over the network.

In some cases, the receiving components may record the information for auditing purposes. But others may call the source component to fetch additional information about the event.

Notification-type events are general-purpose in nature and suitable for broadcasting requirements.

[2] Event-Based State Transfer

This is more like the asynchronous relative of REST.

Instead of REST’s on-demand pull model, event-based state transfer follows a push approach.

Data (id + information) is sent out to be consumed by any components. Some components may create their own local cached copies of the data while others may take some other action based on the data received.

The advantage is that the consumer need not call back the source component for additional information.

The entire information is right there in the event payload.

[3] Event Sourcing

This is pattern not about event transmission but event storage.

The state of an application is determined by a sequence of events rather than by the current state of the data. In other words, instead of storing the current state of an entity, you store a series of events that represent state transitions. These events are then used to reconstruct the current state whenever needed.

According to Martin Fowler,

The fundamental idea of Event Sourcing is that of ensuring every change to the state of an application is captured in an event object, and that these event objects are themselves stored in the sequence they were applied for the same lifetime as the application state itself.

Changes to an entity are not captured as irreversible modifications but are stored as events in an event store.

These changes can be read and processed to recreate the final state of an entity whenever required.

In conclusion, event driven architecture (EDA) offers diverse communication patterns like event notifications, state transfer, and event sourcing. As of this, each serve distinct needs in data transmission and storage. More-significantly, selecting the right pattern depends on system complexity and scalability.

REST API Vs GraphQL

BiKodes — Wed, 14 Feb 2024 14:07:56 +0000

Choosing between REST and GraphQL depends on your specific use case and development requirements.

REST

The following are worthy knowing about REST:

It relies on standard HTTP methods like GET, POST, PUT, DELETE to perform CRUD operations.
It is excellent for simple, uniform interfaces between separate services or applications.
Caching strategies are straightforward to implement.
It can require multiple API calls to fetch related data, leading to chatty interfaces.

GraphQL

The following are to be consider worthy knowing about GraphQL:

It provides a single endpoint and lets consumers precisely query for the data they need.
The clients specify the exact fields required in nested queries, and the server returns optimized payloads containing just those fields.
It supports _Mutations _for modifying data and subscriptions for real-time notifications.
It is great for aggregating data from multiple sources and works well with complex frontends that have rapidly changing data needs.
It shifts complexity to clients and can enable abusive and expensive queries without proper safeguards.
Caching strategies are less straightforward compared to REST.

Nevertheless, the best choice depends on the application architecture and team preferences.** GraphQL** fits better for fluid or intricate frontend requirements, while REST suits applications needing simple consistent interfaces.

Use Rest for:

Simple and consistent interfaces
Caching Simplicity

Use GraphQL for:

Flexible frontend reuirements
Aggregating Data from multiple sources

Conclusively, neither one is a silver bullet but evaluating tradeoffs and limitations is of great significance. Both REEST and GraphQL are solid options for exposing data and powering modern applications.

Carefully analyzing requirements rather than defaulting to one or the other is key to picking the right API approach.

Abstraction in Object Oriented Programming(OOP) For Beginners

BiKodes — Fri, 17 Nov 2023 14:46:27 +0000

Abstraction is a crucial concept of Object Oriented Programming (OOP) in the field of computer science that is used to make code more manageable, secure, and efficient.

It is a technique that involves hiding the implementation details of a class and only exposing the essential features of the class to the user.This allows the user to work with objects of the class without having to worry about the details of how the class works.

In the most simplest way abstraction is hiding the unnecessary details of an object while exposing only the relevant aspects. In a snapshot, it is a process where the programmer hides all but the relevant data about an object in order to reduce complexity and increase efficiency.

Abstraction helps a software developer to define abstract data types. These are classes representing real-world entities, their properties (attributes), and their actions (methods). They also allow us to hide the internal complexities and implementation details of an object from the outside world.

Example One:

Let’s say you have a class called Car that has methods such as start_engine(), accelerate(), and brake(). The user only needs to know that they can start the engine, accelerate, and brake the car, but they don't need to know how these methods are implemented.

Here's what the code would look like:

class Car:
    def start_engine(self):
        # Implementation details hidden
        print("Engine started")

    def accelerate(self):
        # Implementation details hidden
        print("Accelerating")

    def brake(self):
        # Implementation details hidden
        print("Braking")

In the example above, the user can use the Car class in a straightforward way, without having to worry about the implementation details. Someone else worried about that, and a car now acts as an abstraction and hides these details. The user just interacts with a simple interface that doesn't require any knowledge about the internal implementation.

Advantages of abstraction

Reduces complexity
Increase re-usability
Increases security
Loose coupling
Avoids code duplication
Manageable code
Code efficiency

There are two types of abstraction in OOP:

Data abstraction
Process abstraction

Data abstraction (Object Properties)

Data abstraction is like looking at a car from the outside. You don't need to know how the engine works but you only see the essential things such as its color, model, and speed.

In programming, it's about creating a clear and simple "container" for information about something, like a person, a car, a house et cetera.

The container hides the complicated stuff and gives you easy ways to see and change the significant information.

Example:

Think of a Person class in a program. It could have attributes like name, age, and address. These attributes are like the simple, visible parts of a person.

Data abstraction makes sure that a developer can get and set these attributes without worrying about how they are stored or processed inside the program.

Procedural Abstraction(Actons/Functions)

Procedural abstraction is like a magic button. When you press it, you don't need to know how the magic happens, you just know it will do something you want.

In programming, it is about creating easy-to-use magic buttons (functions or methods) that do specific tasks without showing you the complicated steps they take.

Example:

Think of a calculate_are function. The user gives it the size of a shape, and it magically tells you the area without you having to know the math behind it.

Procedural abstraction hides the complexity and lets you use these functions without understanding how they work internally.

Example Two:

The following code demonstrates abstraction by defining an abstract class Shape with abstract methods area() and perimeter(). The Circle and Square classes inherit from the Shape class and provide their own implementations for the abstract methods.

This way, the abstract class Shape defines a blueprint for shapes, enforcing that any class inheriting from it must implement these methods, ensuring a level of abstraction and structure in the design.

from abc import ABC, abstractmethod

# Abstract class
class Shape(ABC):
    def __init__(self, name):
        self.name = name

    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

# Concrete classes implementing Shape
class Circle(Shape):
    def __init__(self, name, radius):
        super().__init__(name)
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

    def perimeter(self):
        return 2 * 3.14 * self.radius

class Square(Shape):
    def __init__(self, name, side):
        super().__init__(name)
        self.side = side

    def area(self):
        return self.side * self.side

    def perimeter(self):
        return 4 * self.side

# Creating objects and using abstraction
circle = Circle("Circle", 5)
square = Square("Square", 4)

print(f"Area of {circle.name}: {circle.area()}")
print(f"Perimeter of {circle.name}: {circle.perimeter()}")

print(f"Area of {square.name}: {square.area()}")
print(f"Perimeter of {square.name}: {square.perimeter()}")

Conclusion

Abstraction is one of the core concepts of object-oriented programming (OOP) languages. Its main goal is to handle complexity by hiding unnecessary details from the user. That enables the user to implement more complex logic on top of the provided abstraction without understanding or even thinking about all the hidden complexity.

Both types of abstraction simplify programming by focusing on what's important (the data or the actions) and hiding the rest (the details). This makes your code easier to understand, maintain, and reuse.Above all they make it a lot easier to handle complexity by splitting them into smaller parts.

The Tempestuous Tale of Docker

BiKodes — Sat, 15 Apr 2023 14:09:46 +0000

Have you ever faced the issue where code works in this environment but doesn't work in the other environment?. What of the code works in a developer environment but the same code doesn't work in the testing or production environment?.

Docker is a tool that helps developers build lightweight and portable software containers that simplify application development, testing, and deployment.

In a nutshell, it is a configuration management tool which is used to automate the deployment of software in lightweight containers. These containers help applications to work efficiently in different environments.

Basically, Docker resolves this issue of an application working in one environment and not working in the other environment. Noticeably, Docker makes it easier than ever for developers to package their software to “build once and run anywhere.”

In software development lifecycle - SDLC(Plan, Design, Development, Testing/Release, Deployment & Maintenance), docker comes into the picture at the deployment stage.
It makes the process of application deployment very easy and efficient and resolves a lot of issues related to deploying applications.

It is the world's leading software container platform. A software a application is made up of frontend components, Backend workers, Databases environment and libraries dependencies, and we have to ensure all this components work on all different and wide range of platforms.

i.e In the shipping business, a container is used to ship a variety of products such as cars, cookers, liquid gas, oil etc revolutionizing the shipping industry.

Docker is a tool designed to make it easier to deploy and run applications by using containers. Containers allow a developer to package up an application with all the parts it needs, such as libraries and other dependencies, and ship it all out as one package.

General workflow of docker

A developer describes all the application dependencies and requirements in a file called dockerfile.

This dockerfile describes steps to create a Docker image. It's like a recipe with all ingredients and steps necessary in making your dish. You will have all the applications requirements and it's dependencies in the image, and when you run the image one gets a docker container.

Docker container in a nutshell is the run time instance of the docker image.It will have application with all its
dependencies.

According to Hykes at PyCon talk, containers are,

“self-contained units of software you can deliver from a server over there to a server over there, from your laptop to EC2 to a bare-metal giant server, and it will run in the same way because it is isolated at the process level and has its own file system.”

The docker image can be stored on an online cloud repository called Docker Hub. One can also store their docker image in their own repository or version control system. This images can be pulled to create containers in any environment

i.e Staging environment and local environment. This resolves the issue of app working on one platform and not on another.

Virtualization Vs Containerization

In virtualization, there's a software called Hypervisor, it is used to create and run virtual machines. We can create multiple virtual machines on a host operating system using Hypervisor.

The VM's(Virtual Machines) have there own OS kernel(Operating System) and doesn't use the HOST OS kernel, this results to overheads on the host platform. Also, in case of VM's , we have to allocate fixed resources to every virtual machine
and which don't change as per application needs leading to a lot of wastage on memory and space.

In Containerization, there's a container engine and a single OS(Operating System). We have multiple containers with there respective applications and dependencies which use the host's operating system(OS). Here the resources are not fixed as they are taken as per the needs of the application hence zero overheads, very lightweight and fast.

However, the need of having a VM on the host OS and then having containers at time arises is some cases such as a need to run a Windows OS on a Linux OS. In such cases we need to have a virtual machine first which will have our windows OS.

The container engine is a docker engine.

Docker Architecture

Docker is a novel way to package the tools required to build and launch a container in a more streamlined and simplified way than was previously possible. It comprises Dockerfile, container images, the Docker run utility, Docker Hub, Docker Engine, Docker Compose, and Docker Desktop.

The core of Docker is Docker Engine. This is the underlying client-server technology that creates and runs the containers.

Docker has a client-server architecture. The command line(CL) is the client and the docker daemon is the server which contains docker containers.

The Docker Engine includes a long-running daemon process called dockerd for managing containers, APIs that allow programs to communicate with the Docker daemon, and a command-line interface.

The docker server receives commands from the docker client in the form of API request(s). All the components of docker client and docker server form the DOCKER ENGINE. The daemon(server) receives the commands from the Docker client through CLI or REST API's.

Docker client and daemon can be present on the same host(machine) or different hosts.

Advantages of Docker

Build an application only once

An application inside a container can run on any system that has Docker installed. So there is no need to build and configure app multiple times on different platforms. Hence, Resolves the problem of the code working on one system and not working on another system.

Less worry

With Docker you test your application inside a container and ship it inside a container. This means the environment in which you test is identical to the one on which the app will run in production.Docker image can be pulled and used on any environment to create a container that hosts the application.

Ease orchestration and scaling

Give that docker containers are lightweight, developers can launch lots of them for better scaling of services. These clusters of containers do then need to be orchestrated.

Portability

Docker containers can run on any platform. It can run on your local system, Amazon ec2, Google Cloud Platform, Rack-space server, VirtualBox etc. A container running on AWS can easily be ported to VirtualBox.

Version Control

Like Git, Docker has in-built version control system. Docker containers work just like GIT repositories, allowing you to commit changes to your Docker images and version control them.

Isolation

With Docker every application works in isolation in its own container and does not interfere with other applications running on the same system. So multiple containers can run on same system without interference. For removal also you can simply delete the container and it will not leave behind any files or traces on the system.

Productivity

Docker allows faster and more efficient deployments without worrying about running your app on different platforms. It increases productivity many folds.

Composability

Docker containers make it easier for developers to compose the building blocks of an application into a modular unit with easily interchangeable parts, which can speed up development cycles, feature releases, and bug fixes.

You can sign-up on for practice.

The Mechanical Intellect (A Treatise on ChatGPT)

BiKodes — Mon, 20 Mar 2023 12:23:14 +0000

ChatGPT is a variant of the original GPT (Generative Pre-training Transformer) language model developed by OpenAI. Generative artificial intelligence describes algorithms such as ChatGPT that can be used to create new content.This falls under machine learning.

ChatGPT is designed to generate human-like text by predicting the next word in a given sequence based on the context of the previous words. The goal of ChatGPT is to enable the creation of more natural and human-like text-based conversations. It's a free chatbot that can generate an answer to almost any question it's asked. It is a tool driven by artificial intelligence.

The first machine learning models to work with text were trained by humans to classify various inputs according to labels set by researchers i.e A model trained to label an accounting entry as a DEBIT OR a CREDIT. This is called supervised training as a human is in charge of "teaching" the model what to do.

The following generation of text-based machine learning models rely on what's known as **self-supervised learning.* This training involves feeding the model a lot of text for it to become able to generate predictions i.e ChatGPT.

Like the original GPT, ChatGPT is trained on a large dataset of text and is able to generate human-like responses to prompts and questions. However, Chat GPT has been specifically fine-tuned to excel at generating conversational responses. This means that it is able to maintain coherence and context across multiple turns in a conversation, and can even generate responses that include appropriate emojis and other chat-specific elements.

One unique feature of ChatGPT is its ability to incorporate user input in real-time. This allows it to generate responses that are tailored to the specific conversation that it is having, rather than relying on pre-determined responses.

Overall, Chat GPT represents an exciting advancement in the field of natural language processing and has the potential to revolutionize the way we interact with text-based conversational agents.

It has already been used in a variety of applications, including chatbots, virtual assistants, and even social media bots. By using GPT to generate responses to user input, chatbots and virtual assistants can have more natural and human-like conversations with users. This can be especially useful in customer service or support contexts, where the goal is to provide helpful and accurate information to users in a timely manner.

GPT has also been used in creative applications, such as generating poetry or fiction. By feeding the model a prompt or theme, it can generate original text that adheres to the given theme or style. This can be a useful tool for writers or artists looking for inspiration or for generating content for social media or other platforms.

This nifty form of machine learning empowers the computer to generate all sorts of new and exciting content. You should exploit the amazing power of generative AI and be amazed by mind blowing creations you can come up with.

However, ChatGPT seems to have issues with counting, solving basic algebra problems, overcoming sexistic and racistic bias that lurks in the undercurrents of the society. This algorithms requires elephantic data to be trained.Nevertheless, ChatGPT will inform you,

"I am not perfect and may not always have the correct answer to every question. Additionally, the information I provide is only as accurate as the data I have been trained on, which has a fixed cutoff date. This means that I may not be able to provide information on recent events or developments that have occurred since the training data was collected."

ChatGPT is a well of succinct answers.

As the technology continues to develop and improve, it is likely that Chat GPT will become an increasingly important tool for businesses, researchers, and individuals looking to create more natural and engaging text-based conversations.

Are you curious to experience the power of AI-powered conversations?. Try ChatGPT, a language model trained on the latest GPT-3.5 architecture. You can SIGN UP here to engage in interesting and informative conversations on a variety of topics.

The impact of Artificial Intelligence has left a profound question unanswered:

Are workers at the median falling behind in the race against machines and automation?.

How To Eat A Tech Frog

BiKodes — Sat, 16 Jul 2022 08:21:12 +0000

It's not that I'm something special, super experienced, or an extraordinary coder, but I earn my living being a self-taught Software Engineer. You have to sacrifice a lot, manage your time well and always be willing to learn.

There are a lot of underwater rocks, but don’t waste a single neuron on the train of thought that begins

“I ain’t smart enough for this”

because quite clearly nothing is impossible.

This is my personal power list on how to push the Tech Frog down your gut.

Decide Your Language

Beginners are very tempted to start learning everything at once. Today you're making games in Unity, tomorrow you're designing web applications, and at the weekend you're developing iOS apps in Swift or learning Machine Learning.

No matter how much you want to, you won't be able to learn it all. It's important to focus on one thing right from the start. Always remember that programming languages are just tools to choose from depending on your goals.

Be Yourself

Technical knowledge is important, but great Tech leaders look for the personality of the person to figure out if he/she would fit in with their team dynamics.

Enjoy

Have fun building the products you work on. If you aren't, it's probably time to switch your team, job, or better yet, build your own company.

Stay Curious

The opposite of dogma is curiosity. So, instead of avoiding tools because of what you read online, check them out if they look like they might be useful.

Every tool was made to solve specific problem(s). But that doesn’t mean it’s a good tool. Maybe its designer fixed a problem you don’t care about or maybe that very solution is flawed yet someone took the time to create it. It might be worth playing around with it a little.

Don’t limit your curiosity to tools. Learn about the problems you’re solving.

“Look past the list of requirements you’ve been given and learn about your customer’s problems. I can’t stress this enough: True mastery comes from understanding the problem you are solving with your code.”

Stay Fit

You'll always have enough work, but do not work overly long hours.Distress when you need to. Go on a vacation. Find a fitness hobby - go to the gym, join a dancing club or play your favorite sport.

Keep Practicing Problems

Keep practicing solving programming problems on your favorite platforms i.e leetcode. It makes your thinking sharp and keeps you prepared for the next opportunity.

Have A Side Project

Build something - anything you love on the side and maybe build it in public. It keeps your creative muscles working and the small entrepreneur in you alive. Such products can bring in unimaginable opportunities if used right. But ensure you complete the project(s).

Network

You'll meet amazing people at work. Network and connect with them. You never know what doors a connection might open for you next. Join tech communities, be professional with your approach.

On LinkedIn, I reached out to Mr. Ali Kassim Hussein a host of Ali Talks Tech who told me this,

“always payback kindness with kindness.”

Learn, Adapt, Repeat

Practice the LAR principle due to the fact that technology changes very fast. Never stop learning new stuff. J Query was a popular choice just 10 years ago while Vue.js and Typescript had no existence.

Don’t Be Afraid To Make Mistakes

If you’re curious, experimenting or making mistakes, it is OK. And it’s not only OK but it’s inevitable. Don’t be afraid.

This isn’t a license to be a “Cyborg.” Measure twice, so you only need to cut once. Pay attention to what you’re doing.

Learn how to use testing to catch mistakes before they happen. Try to test your theories in low-stakes(staging) environments.

Watch Your Personal Time

Programming can be a demanding career. But it’s very rewarding in terms of both personal satisfaction and financial remuneration. This doesn’t write-off the fact that it can also eat your life.

Guard your personal time and make sure you don’t spend too much of it on taking your work home.

“Make sure you don’t spend too much of it on taking your work home. The personal rewards of coding make it easy to blur the line. Get away from the keyboard and get out and see the world. Your sanity will thank you for it, and your career will benefit from broader horizons.”

Don’t Over-Practice

Take regular breaks, rest and you should also keep an eye on your health.When coding, it’s hard to keep a sense of time.

And most of the time you don’t want to be bothered so you spend extensive hours sitting in front of your computer, eating things that are easy/quick, unhealthy and drinking coffee or energy drinks to stay awake and keep momentum.

Eat healthily and drink plenty of water, I know you heard it somewhere, but it’s the truth.
More significantly, if your computer does not have this feature already, make sure you install f.lux in order to protect your eyes from blue light exposure emitted from your screen.

Don’t Compare Yourself To Others

There are kids who are born coding and then there is you and me. Don’t let the progress of others discourage you. It’s not a race, even if it were, you know how quickly things can change. Treat your growth like a marathon not a sprint.

But this is an ongoing process, you’re never too old to start and you’re never done learning. You don’t have to have it all figured out and let me emphasize this one, you don’t need a CS degree.

In fact, a lot of people quit their stable jobs and careers to become self-taught developers.

There isn’t a straight path or a right path to anything. If it’s smooth sailing for you, take a step back and analyze where and why you stopped challenging yourself.

Do Not Worry About Your Age

You can start programming at any age. A talented and hardworking professional, even if he/she is already over 40, will be accepted by any company.

Modern advanced startups employ both young people and people of age. You have a high chance of getting your position. But for this, you need working project(s).

Program Every Day

Once you have written a certain number of lines of code, make a note in your diary or use habit trackers for smartphones. You can also keep a track of your personal commits either by using version control.

It is important that programming becomes your daily routine as taking a morning shower or a meal.

You don't have to create a website or an app every day. Your job is to get used to programming and coding for at least 2 hours or 4 hours a day. Even a little progress is always better than no progress at all.

Avoid Tutorial Hell

Don't get stuck watching too many tutorials known as tutorial hell. They're useful but start working on your own, you will learn a lot more that way. You learn more from your mistakes than your successes (this is the solid truth true in this industry).

Read Docs & Ask Questions

Learn how to read docs and ask good questions, and don't be afraid to ask for help.
Don't believe everyone on the internet, hype is a thing, don't get caught by it. Learn the basics first, then advance to learning frameworks or more complex topics.

People will tell you you must learn the new super cool ultra invincible framework, don't believe them it's usually just BS. Adopt frameworks and tools that have been used for a while and have a big community behind.

Conclusion

These are recommendations from my personal experience and everyone can have a slightly different one. You must know one thing, you can do it! It’s not easy, it may take some time, but you can do it!

The most important thing I would recommend is what my mentor Mr. Josephat Macharia always tells me,

""It's impossible to know everything, you just need to know that it can be done, then when you need it you can research and make use of it.""