Jeremy Maslanko

I Published a Book

Jeremy Maslanko — Sun, 01 Feb 2026 12:00:00 -0400

I can now add 'Published Author' to my resume and if you look at my book on Amazon, I'm sure you will be impressed! Not everyone is able to churn out a book with OVER 40 pages like I can, and I didn't even need to include any pictures! Hopefully by now you realize I am being facetious. My 'book' that I published has less than 300 words. It would be more appropriate to call it a coloring book, however, that is exactly how I want it to be used.

I try to read a fair amount. Any given year, I will read between 15-20 books which does not account for the countless articles I read on HackerNews. I typically read non-fiction, but am drawn to the books that read as if they are fiction. Gripping stories with plenty of character development help me imagine the scenes in my head. And I think that this is one of the most important parts of reading. Simply processing the words on the page does nothing if you are not able to build a world in your head that they represent. That is where Imagine That! comes into play.

For years I have had the idea of creating a book that has simple prompts on the left side of the book with a blank page on the right side. But while the page is blank to start, it should not end that way. After reading a prompt, it is time for the child to take out their crayons/markers/colored pencils and draw what they picture in their head. My hope is that by reading the text and then immediately drawing a picture to go with it, kids will be able to quickly learn to associate the words on the page with more than black letters on white paper.

Now I can admit, this is not the most polished book. There were points in the process that I rushed and I am okay with that. Reason being, I wanted to actually produce this. As I said, I have had this idea for years and never spent any actual time figuring out how to produce it.

Through my research, I landed on self-publishing through Amazon Kindle Direct Publishing. This is an easy way to self-publish a book without having to go through the full publishing process. The perfect approach for a project like this. I doubt any publisher would even respond to my requests to publish something like this, and if they did, I would have an even tougher time trying to convince them to give me an advance. Quite frankly, it wouldn't be deserving of one.

While I would love for this to go viral and make me thousands of dollars a month in royalties, I am realistic. This book has a very high chance of selling less than one copy, and I am okay with that. When I have kids of my own, I will be happy to purchase an author copy for them to work through and bring their imaginations to the page.

For those curious, AI was used throughout the process. But don't worry, an LLM did not help with any of the text outside of the Amazon description. Yes, you heard that right. The prompts in this book are the result of my authentic, human creativity! But LLM's were great for me introducing me to things I have never even thought of coming from a technical background. Things like what should go through a publisher vs. self-publishing, dimensions of the book, dimensions for front/back cover and spine, and a plethora of other things.

As I have been blogging more, I have started to enjoy writing more and more. It is a new skill that I have plenty of room to improve. With that, I have had other ideas for actual books to write and after going through the process of publishing this 'book', I am in a much more confident position to try and tackle those ideas. In the off chance you have a new reader in your life and you purchase this, please share with me how they liked it and if you have any suggestions!

Diagnosing a Faulty Breaker with ChatGPT

Jeremy Maslanko — Mon, 19 Jan 2026 12:00:00 -0400

Let me start with a disclaimer. This is not a how-to guide on how to replace a breaker. Working on breakers, live wires, and electrical panels can be extremely dangerous. If you are not confident in your handyman abilities, the money spent on an electrician will be well worth it. With that out of the way, let us move on to my situation.

My wife and I bought our house in June of 2026. Shortly after moving, we noticed that the dishwasher was not completing its cycles, leaving an unwanted residue on the dishes from the soap that hadn't been fully rinsed off. We actually didn't know that the dishwasher wasn't completing its cycles at first. We saw that it was not running, felt some steam coming out from the vent, and simply assumed it was done. On top of that, we were using a different soap. "Hmmm, maybe it's just the soap." we thought. But that was debunked quickly when we would go and run the dishwasher again, notice nothing happening, and then see that the breaker had tripped.

Great. We just moved into a new house, and now we have to shell out $500-1000 for a new dishwasher. Since there were so many things to do while getting settled in, we (read: I) decided to blissfully ignore the issue and simply walk downstairs every so often and turn the breaker back on. I am not an electrician, but you probably don't want to ignore this as long as I did. Clearly, something isn't working the way it is supposed to, which can lead to bigger problems.

The weird thing was that it actually stopped happening as frequently. A few weeks went by at a time before it would get tripped again. At this point, I have been naively assuming that it is just an issue with a dishwasher, so I let it continue because I am pretty cheap and didn't want to buy a new dishwasher. But all good things must come to an end, and the issue started happening more frequently. Not just when we would run the dishwasher, but every few hours, I would notice that the breaker was switched (the only other thing on this breaker is the garbage disposal, which I would run to test if the breaker was triggered). Fine, I will stop procrastinating and get this figured out.

I have done my fair share of home remodeling. I have done electrical (replaced outlets, switches, and lights), plumbing (shower and sink faucets, garbage disposal replacement), flooring, cabinet, countertop installation and more. You name it, I have likely done it or am confident I can learn how to do it. However, one thing I have not touched is an electrical panel. Whenever I do electrical work, I usually just turn off the main and be done with it. That is the extent of my electrical panel knowledge.

Even though I suspected the issue was with my dishwasher pulling too much power and tripping the breaker, replacing it felt like an expensive way to test that suspicion. Enter ChatGPT. Throughout a back-and-forth dialogue, I described the problem, shared details about what was connected to the breaker, and that it was an AFCI/GFCI dual-purpose breaker. Throughout the conversation, I was guided through a variety of checks to isolate the problem so that I could actually fix the issue.

It was quite a blow to my ego when the first thing I was prompted to do was to unplug the dishwasher and see if the issue continued. So I did that, and it still tripped. What a relief! I don't have to go buy a new dishwasher. Next, I unplugged the garbage disposal and reached the same result. My hunch is starting to be that the issue is the breaker. At least I hoped that was the case because if there was an issue somewhere in the walls, I would definitely be calling an electrician, and that would get pricey. One last thing to check was to make sure that the outlet didn't have any noticeable issues. I turned the power off, pulled it out, and inspected it for any signs of corrosion or water damage. From what I could tell, everything looked normal.

At this point, it is either an issue with the breaker or somewhere in the walls. I was confident I could do this electrical work because I knew that it was pretty straightforward. I wasn't adding anything new; I was simply going to be removing the wires from the existing breaker, taking it out, reconnecting the wires to the new breaker, and finally inserting the breaker back into the panel. But how do I know what breaker to get?

From earlier research, I knew I needed to get the same one that I have. After consulting with my assistant, they gave me a list of things to verify. First, I had to figure out if my panel was BR or CH. I didn't really know the difference, but when I looked into it, it appears that it is just two different lines of products that Eaton offers, with the CH line being the more premium in parts vs. the BR line being more economical. Not surprisingly, my new build (2017) home has the economical version! But had I not been prompted to check for this one, I also wouldn't have known that the two are not interchangeable. I was able to learn which line to use from the sticker on my panel.

The next thing I had to match was the amperage. This was easier to see as the number 20 was on the switch. The last thing I needed to check was that the breaker was also dual-rated for AFCI/GFCI. These are easy to find in the store because, unlike regular breakers packed in boxes, these were hanging with anti-theft devices on them due to the ~$60 price difference ($70 compared to $10 for the regular breaker).

Being in tech, I skeptically listen to LLMs. I understand they are probabilistic and that they have many limitations. It is actually pretty easy to recognize ("You are absolutely correct, that the solution is wrong!" - ChatGPT when I say that the code it provided didn't work). With that in mind, I didn't use ChatGPT to tell me how to actually change the breaker. Instead, I relied on good 'ol YouTube University.

I swapped out the breaker and let it sit for a few hours before plugging anything in. All seemed well, so I plugged the dishwasher in and ran a cycle. A complete cycle ran, incredible! Lastly, I plugged in the disposal, and things still seem to be operating as expected.

In the past, I would have iteratively googled and likely would have gotten to the same result. But that approach can be quite frustrating as I have to piece together different bits of information and try and form a coherent story and path forward. This is where I find LLMs to be most valuable. I can provide information specific to my situation and work through the problem. "AI" didn't magically complete this task for me, but it did help me solve the problem quicker and more confidently.

Rethinking generational wealth

Jeremy Maslanko — Fri, 02 Jan 2026 12:00:00 -0400

When I hear generational wealth mentioned, there is a certain image that I get in my head. Private jets, multiple houses, and never having to think about what something costs. There is probably a staff consisting of landscapers, housekeepers, nannies, lawyers, and accountants just to name a few. It is what I think about when I think of how the ultra-wealthy live their lives. With this image in mind, how do we actually define generational wealth?

I am sure there are many definitions, but Investopedia defines generational wealth as "...generational wealth refers to financial assets passed from one generation of a family to another". That makes sense to me. It is one thing for someone to make a lot of money and spend it all, but that wouldn't be generational wealth. Money needs to survive past a single generation. After all, it is in the name! If you poll people though, it's not as simple as passing down a small sum of money in an inheritance. Looking at this thread on Reddit, you can see that the general consensus is that the amount of money needed to be "generational" is enough to retire as soon as you get access to that money. This lines up with the image I have in my head.

Now that is a fair definition, but the problem I have with it is that it is not achievable for 99% of the population. Very few families will be in this situation. But I like to create goals and work towards them, so I like to define generational wealth closer to that of the Investopedia definition and hopefully people can start to think about it that way too.

You may not be able to give your children an estate that has tens of millions of dollars for them to retire with, but you can give them money for tuition. If tens of thousands of dollars for tuition is too much, maybe you can give them a few grand toward their first house. If a few grand for a first house is too much, then maybe you can let them live with you when they graduate so that they can pay off loans, save for a home/apartment, or maybe both. Generational wealth shouldn't be thought of solely as an option for the ultra-wealthy and there are many ways to set up future generations for greater financial success.

The power of investing is compound interest. Ten thousand dollars invested for 30 years with a 6% return gets you ~$57,000. That is pretty powerful if you make that investment at 30 years old for your retirement. But that same investment for 60 years is ~$329,000! A one-time investment when a child is born leads to a large sum of money for their retirement. Little things like this can lay the foundation for generational wealth and are very achievable.

I recognize that not everybody values generational wealth the same. Many people may want to spend the money on themselves which is perfectly okay! You did work hard to save it, there is nothing wrong with enjoying the money too. My only hope is that we can all think a little looser about the definition of generational wealth and think of it as something you can work toward should you choose to.

A simple LRU Cache in Python

Jeremy Maslanko — Sun, 14 Dec 2025 12:00:00 -0400

In a previous post, I explained some of the basic concepts of how caches work in hardware at the CPU level. As I mentioned to start that post, caching is used in many different areas of computer science. So how can you use this new knowledge you have gained? One way you might want to implement a cache is if you have expensive database calls.

Let's say that you have a web app where you are displaying movie information. When a user searches for a movie, your backend will query your database for the information related to that movie. For a simple web app with a small number of active users, you probably won't run into big performance issues. But we're going to imagine that we have millions of active users because we have created the best movie web app known to mankind.

With so many users, you start to look into where your costs are coming from and realized there is a big line item for I/O requests. Well that makes sense, we do have millions of active users! But you pulled up another dashboard and notice that every time a new movie is released, an overwhelming majority of the requests are for that movie. Armed with your knowledge of caching, you decide to implement a cache to try and reduce the number of calls your backend makes to the database.

Implementation

Caches can become quite complex, especially as the number of cores increases in order to keep all of the data up to date. For our example, we will be looking at a very simplified version. We won't be writing any data to the database, so our cache will only contain data that we have read. Additionally, the cache will be in memory and we will also provide a ttl parameter when we instantiate the class.

from datetime import datetime

class LRUCache():
    def __init__(self, size: int, ttl: int):
        """
        Docstring for __init__

        :param size: Number of entries in cache
        :param ttl: Time To Live (minutes) - Length of time for object in cache
            to be active. Once ttl is past, item is now a cache miss
        """
        self.cache = {}
        self.size = size
        self.ttl = ttl*60 # The timedelta is expressed in seconds, so multiply by 60 to get minutes

    def check(self, key):
        if key in self.cache:
            diff = datetime.now() - self.cache[key]["time"]
            if diff.seconds < self.ttl:
                return True
            else:
                return False
        else:
            return False

    def get(self, key):
        return self.cache[key]

    def add(self, key, value):
        if self.cache.__len__() < self.size:
            self.cache[key] = {"time": datetime.now() ,"data": value}
        else:
            lru_counter = {"time": datetime.now(), "key": None}
            for item in self.cache:
                if self.cache[item]["time"] < lru_counter["time"]:
                    lru_counter = {"time": self.cache[item]["time"], "key": item}
            del self.cache[lru_counter["key"]]
            self.cache[key] = {"time": datetime.now() ,"data": value}

Our cache is pretty simple, but let's break it down. We start by creating a class called LRUCache. This class takes two required parameters. The first parameter is the size of the cache. If we didn't have this, we would end up creating a cache that continuously grows which would eventually slow down our program and run out of memory. How big you make this is dependent on your use case. For our movie app, we might make the size be close to the number of movies released each week as these will be the most accessed movies.

The second parameter is ttl which is short for Time To Live. Common in networking as well as a caching strategy, ttl tells us how long our data is "active". Basically, at some point we will update our data so we want to make sure that we don't continue to access stale data in our cache. We might have users rate the movie so we want to make sure that when we cache the data, we periodically pull our data again so that we have updated data. If we are okay not having real time data, we might make this number 24 hours long so that it is refreshed daily.

In order to create a cache we will need some sort of unique key to index into our data structure. In CPU's we use index bits of the memory location we are accessing. For something like this, we can use a unique value that we might be querying with. In our movie example, we will probably have some sort of movie_id in our database that can be used.

Looking at the methods we have created, the first one is a check method. This simply checks to see if the data is in the cache or not and outputs a boolean value. Additionally, if the data is in the cache, we verify that the data is not older than the ttl value that we have set. If it is, we will return False as if it was a normal cache miss.

The get method... well it gets the data based on the key.

Last but not least, the add method is where a lot of the heavy lifting is done. We have a set size we are allowing our cache to be so that we don't run into any memory issues, so the first thing we do is check to see if our cache is at our max size already. If it is not, then we simply add our data to the cache using a key. If we have hit our max size, we now have to kick out the Least Recently Used item. We first create an lru_counter dictionary with the current time and the key (which is None) to start. Then we will iterate through our cache and compare the time for each item to the time in our lru_counter. If it less than the time in the lru_counter, we will update the lru_counter to be the time of our item and then set the key equal to our items key. Once we have iterated through all of the items in our cache, we will delete the item based on the key in our lru_counter and then add in the data we want.

Walk through

First, we will create a cache with three lines and a ttl of two minutes and add two lines of data:

cache = LRUCache(3, 2)

cache.add("abc", 123)
cache.add("def", 456)

If we call cache.cache, we can see the current contents of our cache:

{
    'abc': {'time': datetime.datetime(2025, 12, 14, 19, 59, 32, 216167),'data': 123},
    'def': {'time': datetime.datetime(2025, 12, 14, 20, 3, 9, 898178),'data': 456},
    'ghi': {'time': datetime.datetime(2025, 12, 14, 20, 4, 31, 427328),'data': 789}
}

We see that abc was the first the item in the cache and our cache is at our capacity. Now, if we were to add a line with the key of zzz, we can see that the cache has kicked out abc.

{
    'def': {'time': datetime.datetime(2025, 12, 14, 20, 3, 9, 898178),'data': 456},
    'ghi': {'time': datetime.datetime(2025, 12, 14, 20, 4, 31, 427328),'data': 789},
    'zzz': {'time': datetime.datetime(2025, 12, 14, 20, 8, 24, 557737),'data': 999}
}

Suggestions

We now have a basic functioning LRU Cache in Python. I glossed over A LOT with this implementation, so here are some things to consider if you actually need to implement this.

It is very likely that you have your application deployed to more than one server. This muddies the water a bit, just as if it were a multi-core cache in hardware. You may want to deploy the cache to its own container that each server calls. You will also probably have to add in some locking functionality so that if you are also using the cache for writes, you keep the data accesses sequential and coherent.
I wrote the code quickly. You might want to create a CacheLine class instead of just a nested dictionary to keep things tidier.
As it is now, you will have to call the methods in order starting with check and then either get or add. A better implementation might have these all rolled into one.
The time for each item is the time when the line was inserted into the cache. If our ttl is set to expire daily, this could lead to problems. We know that when a movie is released, people will go all weekend. If we are not updating any data like ratings, then everytime we read the data from the cache, it might be beneficial to update the time as well.

I finally learned how to study

Jeremy Maslanko — Mon, 08 Dec 2025 12:00:00 -0400

At the age of 30, I have finally found the most effective way for me to learn a subject. I am currently in Georgia Tech's OMSCS program and have been learning about computer architecture. With online lectures, it can sometimes be challenging for me to stay engaged. The vidoes may be playing and I am looking at the screen, but I zone out and end up not knowing what was just taught. This snowballs as I then go on to the next video where I get even more confused because I do not know the concepts that we are building off of.

I have never really been good at taking notes and typically when I study, I simply review slides or re-read textbook chapters. With online lectures, I have rewatched the lectures which has been helpful. But when I rewatch lectures I am still at risk of zoning out. This has largely worked, but I always end up feeling like I do not have a good understanding of the material and quickly lose that knowledge after I am done cramming.

I have had this blog for a couple years but never really got in a rhythm of posting. But I recently was reading comments on a HackerNews post about why people blog and there was a theme I started to notice. People blog so that they can learn or share what they learn. I often read blogs about topics that are new to me and then I thought that it would be nice to do something similar. I decided to write about how caches work at a basic level. By the time I was finished writing, I had such a greater understanding of the material!

As a way to prepare for my final, I began writing blog posts on all of the topics I was reviewing. This helped me immensely and I felt much more confident about the material. It is similar to the idea that the best way to learn something is to teach it. When you do that, you have to make sure you understand the topic so that you can effectively teach it. With an online program, I have less interactions with other students. But writing blog posts gives me the opportunity to teach anyone. I do not intend to publish most of the posts I have written since they are not very polished. However, I still write them as if I were publishing them. This forces me to understand the topic in a way that will allow me to communicate it differently.

Right now I have only been doing this for a few weeks while reviewing material and it is a lot of work. Watching lecture videos while also writing a blog post on it is time consuming, so I do not recommend doing this as a last minute study option. But going forward, I plan to do this from the beginning. My hope is that this will make it easier to understand the material the first time I am introduced to it.

I encourage you to try this method as well. If you need to cram for an exam, it probably won't be the best method. If there is a single topic you are not confident on, try to write a blog post. Hopefully you will find it effective as I have.

How do caches work?

Jeremy Maslanko — Wed, 12 Nov 2025 12:00:00 -0400

I think it is fair to say that most people have an idea of what caching does at a variety of levels. To someone not in tech, "clearing your cache" (also those yummy cookies!) is a way to get your browser to update. So it is understood that some data is stored pretty close to you. To someone in tech, you may understand that caching data is a way to keep it accessible so that you don't have to go and retrieve it. Content Delivery Networks (CDN's) cache webpages (and other data that is distributed) at different locations so that your performance as a user is faster. Great, makes sense!

For both of these examples, the ideas are based on what comes from CPU hardware. When a program is running and fetching instructions/data, accessing memory can be costly (in terms of cycle time).

Locality

When we fetch data from memory, there are two different themes that emerge. Data that was just accessed is likely to be accessed again, and data that is accessed will be close to the data that was accessed in the prior instruction. Those are two examples of temporal locality and spatial locality, respectively. A good way to think about this is in loops. Let's look at the code below.

    int sum = 0;
    for (i = 0; i < 10, i++) {
        sum = sum + arr[i];
    }

For each value between 0 and 9, we add to the sum the value from arr at location i. Each time we iterate through the loop, we are accessing the sum (temporal locality) and we are accessing the next position in the array (spatial locality).

Specifically looking at temporal locality, accessing the value of sum from memory each time we use it can become quite a bottleneck in our program, especially when the loop becomes much larger. This is where cacheing comes in! Instead of going to the main memory every iteration, what if had a smaller memory module on the chip? It would be closer to all of the work that is being done which would make it much faster.

For now, I am only going to focus on a single core with a single cache. Caches in hardware can become more complex with multiple levels (L1, L2, or L3) and multiple cores (how does one core know what is in the cache of a different core?).

Hit or Miss?

Whether we have a cache hit or cache miss, it is pretty straightforward. If the data we are trying to get is in the cache, it's a hit! And if it is not, then it's a miss. The data we are tying to get is based on the address of the location of the data in memory.

So what is the actual cache?

The cache is basically just a lookup table. In order to keep it small to fit on the chip and provide quick lookups, there are only so many records of data in that table. Now that makes sense, but how do we know if the data is in the table? We will use the address of the data that we are trying to access to index into this table. The "records" that I mentioned are actually called blocks or lines, and the length of it is called the block/line size. The block size is typically going to be 32-128 bytes.

We know that blocks are the records in the cache, how do we know how many blocks are in the cache? To calculate this, we just take the size of the cache and divide by the block size. So if we have a 32KB cache and we have 64B block size, then we know that 512 blocks!

The blocks in the cache will have different locations along that block where we can put data. To figure out which block and which section of that block we will put the data, we look at the block offset and block number. We find both of these values from the address.

If we have a 16B block size, the 4 least significant bits of the address will be the block offset and the the remaining bits are the block number. Why 4 bits? $2^4$ is 16, so we get 4 bits. If we had a block size of 32B, then we would have 5 bits used for the offset. Say we had the address of 0x123, which is 000100100011 in binary, the block offset would be 0011 and the block number would be 00010010.

We have said that the cache is indexed by the address and that the data is stored in the cache. But we also said that the cache can contain more than one section of data, denoted by the offset. So how do we know if the data we are looking for is actually in that line? In addition to the data, the cache also keeps track of the cache tags which will keep track of the tags that are in the line.

Until this point, we never really touched on what the values are when the cache is instantiated. The cache may have some random data in it as well as random tags. To know if the data we have in it is actual data or some random gibberish, we will also keep track of a valid bit. This valid bit simply says whether the data is real or not. So, to get a cache hit, we need the tag to match our block number AND the valid bit to be 1.

Types of caches

There are three types of caches:

Fully Associative
Set-Associative
Direct-Mapped

When an address can go to any block, that is an example of a fully associative cache. This is what we have talked about so far. When an address can go to only one block, that is a direct mapped cache. And in the middle, if an address can go to n number of blocks, that is a set associative cache.

Direct-Mapped Cache

Let's say that we have a cache with 4 lines. Of course, we will have more than 4 blocks in memory. In a direct-mapped cache, each block in memory will map to one of the specific lines in the cache. But how? Well just like before, the first few bits will be used for the block address ($2^n$ where n is the value that gets you to the block size). However, instead of all the remaining bits being used for the block tag, we will take the next few bits for the index and the remaining bits after that will be the tag. How many bits for the index? Similarily to the offset, it will be $2^n$ where n is the number that gets you equal to the number of lines in the cache. In our example with 4 lines, then we would have $2^2=4$.

For a more concrete example, consider the address 0x12345678 that is trying to get inserted into a direct mapped cache with 16 lines and has a block size of 32B.

Number of bits:

Number of offset bits = $2^n=32$, with $n=5$
Number of index bits = $2^n=16$, with $n=4$
Number of tag bits = $32$ bits - offset bits - index bits

With the bits above, now we can find the bits that correspond to each chunk. Our hex value in binary is

00010010001101000101011001111000

and we can split it up into tag, index, offset like this

00010010001101000101011|0011|11000.

Looking specificially at the 4 bits for the offset, we can easily figure out which line the address maps to in our cache!

Set-Associative Cache

Similarly to a direct-mapped cache, a set-associative cache only has specific lines that the address is able to access. When we say set, we are talking about a set (or group) of lines in the cache that we are able to put the data for a specific address. For example, if we had a cache with 16 lines and the lines were in sets of 4, we would call that a 4 way set associative cache. There would be 4 sets each with 4 lines.

To find which set our address can be inserted into, we first find the number of sets that are in the cache. The general formula is the number of lines in the cache divided by the $n$ ways in each set, where ways is the number of lines in each set. If you had 32 lines in your cache and 2 ways in each set, then you would have 16 sets.

Just like the direct-mapped cache, we use the index bits to find which set to access. In our 32 line, 2 way cache that gave us 16 sets, which would be 5 bits for the offset ($2^5=16$).

The direct-mapped cache is simply a 1-way set-associative cache!

Fully-Associtive Cache

A fully-associative cache is a cache where any address can go to any line in the cache. When that is the case, we have no offset bits and just have the tag and offset bits because there is no need for indexing.

Replacement Policies

Now that we know how caches are organized and the different types of caches, we have to decide what to do when we are trying to write to the cache and it is full. A few different options could be to randomly kick out an entry, choose whatever was first in the cache (FIFO), or choose whatever was Least Recently Used (LRU).

Least Recently Used

Like the name implies, in an LRU cache we will replace the item in the cache that has least recently been used. To keep track of what has been used when, we will add an LRU counter. Let's say that we have a cache with just 4 lines. Each line in the LRU counter will have a value between 0 and 3, with none repeating. 0 is the line that was least recently used and 3 is the line that was most recently used. When we need to replace a line, we will place it in the line that has the LRU counter value of 0. When we do this, we will change the LRU counter of that line to 3 and then decrement all of the other values.

If we are accessing the most recenlty used line (LRU counter of 3), then we do not need to change any of the values of the LRU counter because they are just the same as before.

But what happens if we want to access something that is in our cache, but say it has an LRU counter of 1? Well that line that we access will have its LRU value change to 3 and then anything with a value larger than the value just accessed (2 and 3 in this case) will be decremented. The line with the LRU counter value of 0 will stay the same.

Write Policy

The last topic I will touch on is the write policy. First we have to decide what to do when there is a write miss. In a write miss, we want to write a value to the cache but it does not exist. At that point, do we write it to the cache or not? Simiply put, in a write allocate cache, we will write that value to the cache and in a no-write allocated cache we do not. Write allocate caches are what is commonly used and the reasoning is related to temporal locality. For any item we are accessing, we are likely to access that again so we put it in the cache to make it quicker to access.

In addition to the allocation, we also have to decide if we will write the value to memory. In a write-through cache, we will update the memory immediately on cache write. The other option is a a write-back cache, where we only write to memory when that value is being replaced. This reduces the total number of times we have to access the memory. As you can imagine, write-back caches are much more popular.

Write Back Caches

Further exploring write back caches, consider two scenarios: we wrote a block to the cache and read block from memory into the cache. In both scenarios, the cache has a value. These two scenarios work differently when we have to replace that block in the cache. In the first scenario, the cache has the newest data value so when we replace it, we will have to write the current value in the cache to memory. But in the second scenario, the cached value is the same value that is currently in memory, so we do not have to write it to memory. How do we know which scenario we have? We use what is called a dirty bit. When the dirty bit is 0, we know that the value is "clean" or that we don't need to write to memory. If the dirty bit is 1, the value is "dirty" and we have to write it to memory.

Hopefully after reading this you have a better understanding of how caches work. This article only scratched the surface, and most notably only talked about single caches in a single core chip. As you add in additional levels of caches and multiple cores, the complexity of managing caches increases.

Understanding Python Relative Imports

Jeremy Maslanko — Sun, 26 Oct 2025 12:00:00 -0400

One thing that has always tripped me up with Python is the import system. Everytime I think I understand how it works, I run some code and get more import errors. But I think I now have a complete understanding of how it works, so let's dive in.

What is `sys.path`?

To see how the Python import system works, we have to start by understanding where Python looks for code when there is an import. This is in the module search path, which is inititialized when Python starts. By printing the sys.path, we can see the list of paths that Python will be searching for modules. I created a folder named package, and we can see the repo structure below:

    package/
    |-- fruits/
    |   |-- __init__.py
    |   |-- apple/
    |       -- __init__.py
    |       -- slice.py
    |-- vegetables/
        |-- __init__.py
        |-- celery/
            -- __init__.py
            -- dice.py

Here is a sample output from print(sys.path):

[
    '/Users/Jeremy/Documents/Projects/package',
    '/Library/Frameworks/Python.framework/Versions/3.13/lib/python313.zip',
    '/Library/Frameworks/Python.framework/Versions/3.13/lib/python3.13',
    '/Library/Frameworks/Python.framework/Versions/3.13/lib/python3.13/lib-dynload',
    '/Library/Frameworks/Python.framework/Versions/3.13/lib/python3.13/site-packages'
]

There are five different paths that are listed. The first one is associated with the file I was running, and the remaining are different standard paths. Additionally, if you were to manually edit the PYTHONPATH, then those would be listed as well.

Let me also share what is in the two Python files.

# dice.py
import sys
from fruits.apple.slice import slice_apple

def dice_celery():
    return "Celery has been diced."

if __name__ == "__main__":
    print(sys.path)

# slice.py
import sys

def slice_apple():
    return "Apple has been sliced."

if __name__ == "__main__":
    print(sys.path)

Module vs. Script

From the root of the project in the package/ folder, the above sys.path output was from python3 -m vegetables.celery.dice. When I run that command with the -m option, the code is ran as a module. When you do that, the path that is added to sys.path[0] is from where the code is executed from. So if I run python3 -m apple.slice from the fruits/ directory, then sys.path[0] will be:

'/Users/Jeremy/Documents/Projects/package/fruits'

But what happens if I run python3 -m celery.dice from the vegetables/? We get an import error!

Traceback (most recent call last):
File "<frozen runpy>", line 198, in _run_module_as_main
File "<frozen runpy>", line 88, in _run_code
File "/Users/Jeremy/Documents/Projects/package/vegetables/celery/dice.py", line 2, in <module>
    from fruits.apple.slice import slice_apple
ModuleNotFoundError: No module named 'fruits'

Now why is that? We ran it as a module and it worked from the package/ directory and it worked. Well, if we comment out the import statement and see what the sys.path is, we get:

'/Users/Jeremy/Documents/Projects/package/vegetables'

Because our sys.path is in the vegetables/ directory, that is where we are telling Python our project root is. With that as the root location, Python will only look at folders that are downstream of the root path and will not infer anything upstream is part of the module.

What is important is that we are running the code as a module. If we run a progam just as a Python script, we have slightly different behavior. With the import still commented out in dice.py, regardless of where we run the code from, the value in sys.path[0] will be the location of the file itself.

Running python3 dice.py from the celery/ directory gives us:

'/Users/Jeremy/Documents/Projects/package/vegetables/celery'

If we ran python3 vegetables/celery/dice.py, we get the same outuput!

One thing to remember, your import has to be relative to where Python thinks your root directory is. This can be easy to forget as your project grows and you rework your folder structure.

Hopefully this will help you navigate the Python import system when working on your projects!

Similarity Search Explained

Jeremy Maslanko — Sun, 14 Jan 2024 12:00:00 -0400

Large Language Models (LLM's) have exploded in popularity in the last year. As such, I have found there to be many new "AI Practitioners". These are people who I have found to not have the strongest understanding of some of the technical details surrounding these models and their various applications. This is not to generalize any one individual as not being technical. A software engineer who creates a Retrieval Augmented Generation (RAG) model is certainly a technical person, even if they don't understand all of the math behind it. But if you are new to the world of AI/ML and are looking for a better understanding of some of the math that makes these tools so powerful, continue reading.

In this post, we will look at a few of the similarity measures that are used for retrieval in vector databases. I mentioned the RAG model above, but what exactly is it? And why is it so commonly used? The basics of the model are as follows: a user types a question, that question is compared to a database of documents, and then the document in that database that is most similar to the question is returned. After that document is returned, you combine it with the original question and run that complete text through the LLM. In fact, I would say that the similarity search is the most important part! Sure the LLM's that we are using are very impressive, but all we are really doing is having it jumble up the words that we enter into the prompt. The hard part, answering the question, comes from the document that was returned from the vector database.

What makes this such a great application for companies to implement, is the ease in which you are able to now have a custom chat application on domain specific knowledge. There is no training of a transformer from scratch on some large corpus of private data, or even any finetuning. Simply load the documents into a vector database, query it based on some given text, and there you go, you have the answer you were hopefully looking for! There are plenty of tutorials on how to implement these solutions, so I will leave that for others to explain.

What's a vector embedding?

Before diving into the various approaches for calculating the similarity, a brief overview of what vector embeddings are would be helpful. In simple terms, it is a numerical representation of words. There are a variety of ways to come up with the values that represent each word or token, but that is not important right now. Using libriaries like LangChain and HuggingFace can allow you to easily convert the text that you have into numbers. And once that is done, you can load them into a database.

So, how do they work?

The document that is returned is the one that has the smallest distance between the document and the question that was asked. There are several ways to compute this distance between documents. As a reminder, when I refer to the documents, I am referring to the numerical representation of these documents (i.e. their embeddings).

There are three main ways to compute the distance and they are as follows:

Euclidean Distance
Manhattan Distnace
Cosine Similarity

Euclidean Distance

Below is the formula for the Euclidean distance:

$d = \sqrt{\sum_{i=1}^{n}(x_i - y_i)^2}$

It may look familiar from a middle school math class. If we were comparing two, 2-dimensional vectors, this formula would be the same as the Pythagorean theorem to find the length of the hypotenuse of a right triangle. When we have vectors with more than 2 dimensions, we are calculating the same thing, just in a multi-dimensional space.

Manhattan Distance

If we are in a city, we can think of the Euclidean as the direct distance between two points as if we were able to walk through buildings. The Manhattan distance essentially takes the buildings into account and assumes we can go only in two directions (if we were dealing with two dimensional vectors). For this reason, the Manhattan distance is also called the Taxicab distance. The formula is as follows:

$d = \sum_{i=1}^{n} |x_i - y_i|$

As we can see, the Manhattan distance is just the sum of the absolute difference between each element of the two vectors.

Cosine Similarity

The last distance measurement we will discuss is the Cosine Similarity. This metric focuses on the angle between two vectors and not the magnitude. This is beneficial when the magnitudes of two vectors are different which may sway the Euclidean distance to not classify them as similar. But if for our data we do not care about the magnitude, the Cosine Similarity may show that the two are truly very similar.

$cos(\theta) = \frac{\sum_{i=1}^{n} x_i \cdot y_i}{\sqrt{\sum_{i=1}^{n}(x_i)^2} \cdot \sqrt{\sum_{i=1}^{n}(y_i)^2}}$

In the numerator, we simply multiply each element pair of the two vectors and then sum their results. The denominator has a bit more to it. Here we are multiplying the L2 norm of each vector. The L2 Norm is calculated by taking the square root of the sum of the squares of each element in the vector.

Python Implementation

Now that we have an understanding of the formulas, we can implement these in Python.

import numpy as np

class VectorSimilarity():
    '''
    Class for vector similarity search.

    - x, y: equal length numpy arrays
    '''

    def __init__(self, x: np.array, y: np.array) -> None:

        self.x = x
        self.y = y
        self._validate_params()

    def _validate_params(self):
        if isinstance(self.x, np.ndarray) and isinstance(self.y, np.ndarray) and len(self.x) == len(self.y):
            pass
        else:
            raise TypeError('Input arrays must be equal length ndarrays!')

    def euclidean(self):
        '''Returns the euclidean distance between the two vectors'''
        return np.sqrt(np.sum(np.square((self.x - self.y))))

    def manhattan(self):
        '''Returns the manhattan distance between the two vectors'''
        return np.sum(np.absolute(self.x - self.y))

    def cosine(self):
        '''Returns the cosine similarity between the two vectors'''

        num = np.sum(self.x*self.y)
        denom = np.sqrt(np.sum(np.square(self.x)))*np.sqrt(np.sum(np.square(self.y)))
        cos_theta = num/denom

        return cos_theta

Hopefully now you have a better understanding of some of the similarity metrics used in vector retrieval. This functionality is at the core of RAG models when using LLM's on domain specific documentation!

I'm Sick of LLM's

Jeremy Maslanko — Sat, 16 Dec 2023 12:00:00 -0400

A few hours after Google announced their new family of language models named Gemini, I was asked what I thought about them. I gave an honest answer, that I hadn't really looked into them. I saw a headline that they had were released, and shrugged it off. Why? Well, I'm kind of sick of them..

When I say this, it is not meant to discredit or downplay how impressive the models are. The ability to ask a question about linear algebra followed by a prompt to write a poem in the tone of pirate and confidently get a response that is generally accurate is incredible. I remember less than two years ago messing around with BERT and its variants, but being dissapointed in respones that were nonsensical.

But with that said, I've become a bit unimpressed with new models. Most of them tell you that they are some percentage point better than other models on a variety of different metrics. And while that is progress, it's just not that exciting to me. On top of that, the architecture of the models are largely the same, which means the differences stem from variations in training data. And if your model is only performing better because your model has ___ billion parameters more than the last, great. I am happy that you and your team have access to more compute.

What has been impressive to me, are the smaller models. In fact, I think most of the productivity gains we see will be from these smaller models. Retrieval Augmented Generation (RAG) models are one of the more common ways to use LLM's on domain specific data. The magic sauce for those is not the LLM, but the similarity search returning the context. As long as the LLM is able to produce coherent text, all it needs to do is mix up the input to provide the answer. In simple experiments, I have found that 3 bit quantized models are more than sufficient compared to 8 bit or even full base models. Perhaps I should run an actual experiment, I am a data scientist after all.

Maybe I'm not sick of LLM's. Maybe it's just that I am sick of people talking about "AI" as if it's something magical new inventions. AI is not some sentient thing, its a vague way to refer to complex applied math. Or maybe I am just a jaded data scientist sick of hearing people talk about AI who couldn't tell you how to multiply two vecotrs or explain what a p-value is. It's probably the later.

My First Post

Jeremy Maslanko — Wed, 13 Sep 2023 00:00:00 -0400

Welcome to my blog! I am very excited to begin this project as I expect to be able to learn a lot from it. My hope is that you will be able to pick something up along the way, whether it is a better understanding of a specific topic or an appreciation for a different viewpoint.

As I am sure you may have noticed, this isn't the prettiest site at the moment. I wanted to build this blog from scratch, so I have some work to do. But at the same time, my motivation to work on formatting HTML/CSS remains low.

I have no set plans on how often I will post. My hope is that I will find a blend of short, quick posts that are easier to churn out mixed in with some longer posts that are more thoughtful and take more time. The topics will vary from tech to math to finance and business. These are all topics that I find very interesting. Additionally, I am sure I will write about other things that are not part of those broader topics. That said, I do hope to post with some sort of regularity.

If I write about anything and make an error, please reach out so that I can correct it. My intention will never be to lead anyone astray. Feel free to reach out if you would like to discuss anything or talk about something I have written about. Just as I hope you can learn something from my posts, I am sure there is more that I can learn from you.

And with that, I can't think of anything else to share at this moment.