Software Development Logs

Adding two integers without the + or - operators using bitwise XOR, AND, and masking in Python

Practical patterns for managing nested timeouts, out-of-band recovery, and idempotency when dynamically spawning pods with dispatchers

Finding grid coordinates that drain to both oceans using reverse DFS from ocean boundaries in Python

What happens when mass pod creation exhausts node resources, how progress deadlines behave, and managing rollbacks in GitOps

Finding the minimum window substring containing all target characters with two pointers and have/need counts in Python

Finding the contiguous subarray with the largest product using dynamic programming tracking both min and max in Python

Detecting a cycle in a singly-linked list using Floyd's two-pointer algorithm in Python

Setting up a lightweight local Kubernetes environment with OrbStack and declarative GitOps deployments with ArgoCD

Counting palindromic substrings via odd and even expand-around-center checks in Python

Sliding window solution tracking maximum character frequency in Python

Computing the longest common subsequence of two strings with a 2D dynamic programming table in Python

Deep copying an undirected graph using a hash map and DFS recursion in Python

Reversing a 32-bit unsigned integer using bitwise shifts and masking in Python

A Python sliding-window solution using a set to maintain unique characters

An iterative Python solution that reverses next pointers in place with three references

How I use lecture notes, questions, retrieval, and revision to make AI-assisted writing part of studying

How a support vector machine chooses a decision boundary by maximizing its margin

A Python matrix simulation using direction vectors and in-place visit markers

An O(n²) Python DP solution that tracks the longest increasing subsequence ending at each index

Closing my Codeit AI Engineer Sprint chapter early after accepting an AI agent engineering role

How accuracy, recall, precision, and F1 expose different kinds of classification errors

A WordDictionary implementation using a Trie for storage and DFS for wildcard search

How decision trees choose splits, why they overfit, and how voting, bagging, and boosting address their weaknesses

A Python two-pointer solution that moves the height limiting the current area

How classification models measure probability errors and learn from them

A Python stack solution that validates bracket type and closing order

How fixed lengths, terminators, length prefixes, and HTTP chunks define data boundaries

Implementing a Trie with fixed 26-child nodes and an is_end marker

A Python dynamic programming solution for checking whether a string can be segmented by a word dictionary

Encoding and restoring a list of strings by recording each string's length and a delimiter

The third weekly paper on decision trees, major boosting models, and the difference between PCA and factor analysis

My OpenAI Build Week hackathon submission story

Why linear regression is unsuitable for classification and how logistic regression separates classes with probabilities

Grouping anagram strings by using each sorted string as the hash map key

A Codeit mission on reading feature context, outliers, and model behavior in Kaggle's Bike Sharing Demand data

Why GPT-5.6 roadmap generation kept failing after schema validation passed, and why the final fix required replaying the real application request

How feature scale affects model training and why Ridge, Lasso, and Elastic Net depend on comparable inputs

Connecting Study and Interview outcomes to FSRS so active recall quality drives the next review

Adding OpenAI text, speech, and Realtime paths without replacing the existing Gemini relay architecture

A one-pass Python solution that tracks the lowest earlier price to calculate maximum profit

The second weekly paper on how machine-learning models learn, fail to generalize, and are evaluated

The main ways machine-learning systems learn from data and how they differ

A Python DFS and memoization solution that stores the minimum coin count for each remaining amount

A Python DFS and backtracking solution that marks visited board cells in place

How vectors, matrices, and linear systems connect to machine-learning inputs and weight calculations

A Python binary search solution for the minimum value in a rotated sorted array

Adding privacy-safe structural telemetry for production RAG calls, admission, scores, latency, and source mix

Separating transcript scope, eligibility, and evidence states so partial interviews are not scored as complete sessions

The first weekly paper on the mathematical language of machine learning and the preparation of data for analysis

A Python DFS solution that compares the depths of the left and right subtrees

Reviewing how descriptive statistics and visualizations explain center, spread, and distribution shape

A Python solution that merges two sorted linked lists with a dummy node and moving pointers

Separating stable learner memory from query-specific retrieval after correct chunks ranked first but missed the score threshold

A Python recursion and memoization solution that counts valid one-digit and two-digit decodings

A Python solution using Kadane's algorithm to find the maximum sum of a contiguous subarray

A Python backtracking solution to Combination Sum using a start index and pruning

Building a source-scoped RAG pipeline and validating its effect on real Study responses

A lesson note on filtering data, creating values, and aggregating groups with Pandas

A first pass through selecting, combining, and cleaning tabular data with Pandas

A lesson note on vectors, matrices, NumPy arrays, shape, axis, and basic array operations

A Python solution that counts 1 bits by repeatedly dividing by 2

A two-pointer Python solution for checking palindromes after normalizing alphanumeric characters

Notes on Python sequences, file I/O, duplicate removal using sets, and OOP fundamentals covered in the second class of Codeit Sprint Main Course.

A DFS Python solution for checking whether a BST is built with valid value ranges

A first-class Codeit Sprint note on data science, MLOps, and Python basics.

A 3Sum solution using sorting and a two-sum-style hash map approach.

A left-product and right-product solution for Product of Array Except Self.

A recursion and memoization write-up for the Climbing Stairs problem.

A learning note on how hypothesis functions, loss functions, partial derivatives, and gradient vectors lead to gradient descent.

A comparison of sorting and character counting for the Valid Anagram problem.

Solving the rob-or-skip choice with top-down DP and memoization

Using a set to count each consecutive sequence only from its starting point

Using frequency counting and bucket arrays to return the top k frequent elements

Comparing brute force, two-pass hash map, and one-pass hash map approaches for Two Sum

Stabilizing live interviews by defining reliable boundaries for user and assistant turns

Comparing brute force, sorting, and hash set approaches for duplicate detection

A system design practice note on separating real-time LLM serving from asynchronous feedback collection at 20K peak TPS

Solving BST range sum through BFS, DFS, and prefix sums

A learning note on linear regression, mean squared error, and why the loss function takes theta as input.

A learning note on partial derivatives and gradients from a machine learning fundamentals course

A Codeit AI Engineer Sprint note on reviewing functions, rates of change, and the basic idea behind derivatives

A system design note on asynchronous document processing, GPU workers, queues, and storage choices for Document AI

Why a modified Bellman-Ford approach fits the K-stop constraint better, and some implementation notes

A summary of matrix addition, scalar multiplication, matrix multiplication, element-wise multiplication, and NumPy operations

Reviewing the fundamentals of machine learning and introductory linear algebra in the Codeit pre-course.

A Codeit AI Engineer Sprint pre-course note on dictionary view objects, string immutability, and Python indexing

A short Codeit AI Engineer Sprint pre-course note on revisiting Python lists and for loops

A short note from the Codeit AI Engineer Sprint pre-course on reviewing Python basics, PEP 8, and scope

Returning to a structured learning routine to keep growing as a hands-on engineer in the AI era

Managing Gemini Live credentials and long-lived sessions through a backend WebSocket relay

Managing voice opt-in, waiting, playback, and cancellation as one product flow

Aligning Kovill’s reply style, question progression, and language with product-owned state

Adding standalone coding practice without breaking the existing session and dashboard flow

Removing software-interview assumptions to support interview practice across professions

Evaluating full interview conversations with a typed LLM-as-a-Judge pipeline

Building credits, consent, and operational boundaries before accepting payment

The first Tail Villain beta launch, from production deployment failures to preparing the product for its first users

Recovering interview control flow lost during a prompt and grounding refactor

Enforcing LLM cost limits in the backend and modeling their operational impact

Treating active sessions as resumable work while preserving truthful progress

Connecting spaced review to a landing-page story without letting RPG flavor obscure the product

A Tail Villain note on treating LLM completion signals as advisory instead of letting them end sessions unconditionally

A Tail Villain note on study telemetry and the move toward a roadmap-level interview hub

Turning study mode from a one-off chat into a session with state, progress, and a report

How interviewer personas moved from a selection UI into distinct interview and study flows

What bilingual support revealed about local UI state, account preferences, and dashboard structure

Connecting interview results to topic progress, review timing, and the practice loop

Provider boundaries, latency handling, and failure modes that surfaced while wiring Gemini and Ollama into the same product

The polling bug that made completed backend analysis keep looking like it was still running

I pressed the button and waited thirty seconds. Technically, nothing was wrong. That was the problem.

The starting point of Tail Villain, built around the gap between knowing something and retrieving it under interview pressure