Forem: ivy imoh

The Power Of P2P

ivy imoh — Mon, 23 Mar 2026 15:00:49 +0000

Beyond my repo: What a P2P(Peer to Peer) Audit taught me about Tech Culture

"Doing audits is a core part of our learning process, but this past week was a total eye-opener.

Our module set a challenge: two weeks to complete two projects. The cohort split between Groupie-Tracker and Net-Cat. My team dove into Groupie-Tracker, where I took the lead on the models and API fetching. I really leaned into Agile methodology and Test-Driven Development (TDD);it was a masterclass in clean, functional Go code.

Then came the twist.

The audit system is a lottery; you might end up auditing a project you didn't even touch. I drew Net-Cat. Not wanting to show up empty-handed, I spent time brushing up on the concepts so I could ask the right questions.

In tech, you meet two types of people: those who guard their knowledge and those who are thrilled to share it. I got lucky. This group didn't just 'pass' the audit; they invited me into their logic. They explained every line of code as a collective, and I left that session feeling significantly smarter.

The Win: P2P isn't just about code review. It's about navigating different social cues, building bridges between teams, and realizing that the best way to learn is often to let someone else teach you.

Push_Swap, Paralysis, and Why I Finally Chose the Turk Algorithm

ivy imoh — Tue, 03 Mar 2026 22:12:19 +0000

This past week, I almost hid behind “learning.”

I was working on the push_swap project — a constrained sorting challenge where you must sort a stack of integers using only a limited set of stack operations (sa, pb, ra, etc.). No built-in sort. No shortcuts. Just operations and strategy.

Instead of building, I kept researching.

Radix sort?
Turk algorithm?
LIS-based approach?
Chunking?

I wanted the best algorithm before writing a single serious line of code.

Time was moving. I wasn’t.

Eventually, I realized something uncomfortable: I was optimizing for certainty instead of progress.

So I started building.

The Structure: Two Executables, One System

Push_swap requires two programs:

push_swap → generates sorting instructions

checker → reads instructions and verifies if the stack ends sorted

That separation is powerful.

push_swap does the thinking.
checker enforces correctness.

It forced me to design properly:

Parse CLI arguments safely

Detect duplicates

Handle both "3 2 1" and 3 2 1 formats

Exit early if already sorted

Output instructions exactly as required

It stopped being “just a sorting problem” and became a systems problem.

My Flow

I structured my program like this:

Parse input

Validate integers

Reject duplicates

Check if already sorted

Handle small cases (2–3 numbers)

Delegate large input to the Turk algorithm

For 3 elements, I hard coded permutations. Why?

Because there are only 6 possible arrangements. A general algorithm would be overkill. Optimizing small cases reduces total move count dramatically.

Then came the real decision: what algorithm to use for larger inputs.

Why I Chose the Turk Algorithm

Radix sort is simpler to implement. It’s deterministic. It works.

But push_swap scoring is based on number of moves, not time complexity alone.

Radix tends to produce more operations.

The Turk algorithm is different. It’s a greedy insertion strategy:

Push elements from stack A to stack B

Calculate the cost to insert each element back into the correct position

Choose the element with minimal rotation cost

Optimize rotations using combined operations (rr, rrr)

Instead of blindly grouping bits (like Radix), Turk evaluates cost dynamically.

It’s smarter about move count.

That mattered to me more than implementation ease.

Was it harder? Yes.

Did it force me to understand rotation cost pairing and stack state deeply? Absolutely.

But it produced better results within scoring constraints.

What I Learned Technically

Early exits matter.
Checking if the stack is already sorted saves unnecessary computation.

Small-case optimization is powerful.
Sorting 3 numbers manually is faster and cleaner than general logic.

Instruction output must be deterministic.
The checker reads from STDIN. One wrong newline breaks everything.

Algorithm choice depends on constraints.
If this were real-world production code, I’d use sort.Ints().
Here, the constraint is operations. That changes everything.

Architecture > brute force.
Separating algorithm logic into its own package made iteration easier.

What I Would Improve

If I refactor this project, I would:

Implement an LIS (Longest Increasing Subsequence) strategy to reduce pushes.

Add a post-processing compression layer to merge:

ra + rb → rr

rra + rrb → rrr

Refactor stack operations into methods for stronger cohesion.

Benchmark Turk vs Radix for 100 and 500 elements.

There is always a cleaner abstraction.

The Real Lesson

The biggest breakthrough wasn’t algorithmic.

It was mental.

I was stuck trying to choose the perfect approach before writing code.

Once I built a working version — even if imperfect — clarity followed.

Progress created insight.

Push_swap isn’t really about sorting.

It’s about thinking under constraints.
It’s about minimizing cost.
It’s about separating generation from validation.
It’s about designing small systems that behave predictably.

And most importantly:

Movement beats theoretical perfection.

Build first. Optimize second. Reflect third.

That’s the real algorithm.

Why "Hello, World"

ivy imoh — Sat, 07 Feb 2026 14:15:18 +0000

At the beginning of every language, the program is simple, and universal,"Hello,World!" Why?
Ever wondered? Of all the words in the English vocabulary, why this. I took myself through the journey of figuring out why the most basic program was universal across all programming languages. I found something very interesting yet common, how we casually say "hello" each time we call or pick a call, how we unconsciously do a 'mic check' before speaking.I found out that Graham Bell did not come up with 'hello' neither was it some romantic phone call to her wife as the tale goes. It was a lab accident and the first time a signal was sent from one side to another giving "birth" to our now phones. Sometimes a beautiful story is better than a reality. Sometimes the illusion of it makes a great cover!
Now back to our topic, "hello, world" is used to identify that the languages' environment is installed correctly and that the operator understands basic for you.
It is essentially a "handshake"
A way for the machine to tell the human that they are understanding each other.
I went further into my research of 'hello world' and learnt what happened behind the hood, how strings were converted into ones and zeros.
I was intrigued by the fact that each language printed their "hello, world" in a certain way.

As I begin my 'handshake' into the Tech world, walk with me through this journey.

Poetry and coding

ivy imoh — Fri, 23 Jan 2026 08:11:02 +0000

Who would have thought that not tying my identity to a role would propel me to these waters. Where, I dream of fixing bugs and running code…not in writing feelings and escaping reality.
If you had asked me at 18, I would have told you words are my way into the world.
Perhaps it still is!!