In today’s article we’ll be looking at what happens when you point python towards a file under the hood.

If you haven’t looked at the previous lesson on setting up your development environment for python - please do so first. That way you’ll be able to walk through all the source code that we’ve provided in this article.

You can check out the article here 👉 Setting Up Your Python Development Environment

So, without ado, let’s start our python programming language journey.

If you’re running python locally on your computer, I highly suggest using VSCode - a lot of a random guys online will claim that emacs or vim is the superior experience but they are both really difficult to pick up for a beginner.

I would say that while you are learning to code, reduce the complexity that you need to deal with and focus more on the programming side. If the program compiles, you’re good.

Functionality first, ergonomics second.

Programs

Last week, we wrote our first python program that printed out Hello World! to the screen when we ran it. If you don’t remember exactly what we did, here’s a quick recap.

First we created a new python file - I suggested calling it main.py but you can call it whatever you want

We then wrote out these few lines of code

content = "hello world"
print(content)

We then opened our terminal and ran the commands

~/UnawareSpottedGeeklog$ python3 main.py 
hello world

This in turn netted us the output

~/UnawareSpottedGeeklog$ python3 main.py
hello world
~/UnawareSpottedGeeklog$ 

But what’s happening here under the hood?

Mental Model

I find it useful to think about all computer programs through a simple input and output model - it’s the easiest thing to use and it works surprisingly well for a large range of programs.

Let’s start from the top

1. We wrote a program

2. We ran a command called python3 main.py

3. We got an output

Compiled Languages vs Interpreted Languages

So what happens when we run the command?

python3 main.py

For that matter, what even is a compiled language versus an interpreted language and why does it matter?

Analogy

To make matters a bit more easily, let’s imagine that you’ve been thrust into a foreign country where you don’t speak the language.

Now, you have two choices if you want someone to help you with something:

Read more

In today’s article we’ll be looking at

• What are some of the advantages and disadvantages of using python as a programming language

• How to set up your python environment and begin programming in Python.

So, without ado, let’s begin to start our python programming language journey ~

Why Python?

If you’re new to programming, you might be wondering to yourself why use python? In other words - among the million programming languages that are out there, why should we bother to use python.

In my opinion, there are two reasons for this

(1) It has a lot of libraries written for it

(2) It’s easy to interview in

» It has a lot of libraries

A programming language is easier to program in when it has a large variety of libraries that have been written for it. This enables you to do more as a programmer because you don’t need to spend your time worrying about implementing the basic stuff.

If you want to do machine learning, you’ve got Tensorflow or Pytorch which both have been optimised for GPUs. If you want to do web programming in python, you’ve got Django or fastAPI. If you want to do web3 programming, well you’ve got brownie and Ape right out of the box.

All it takes for us to take advantage of these fantastic libraries is

pip install <library name>

and we are done with the initial setup.

» It’s easy to interview in

I always use python to interview in.

This is because the type system is forgiving and the code reads like human pseudocode. Many basic operations such as allocating space, managing array sizes and operations like getting the length of an array are provided with easy functions.

Compare this to something like C++ ( Not a bad language, just not something I’d interview in ) where we get error messages like what we see below.

Read more

We’ve been working hard to look at data structures over the last few weeks and so today’s article will be a welcome break from it for a while.

In today’s article - I’m going to go through my current note taking process as a programmer and how it’s helped me to save my ass multiple times. I was inspired to write this after reading a similar article from BowTiedCrocodile at his substack The Bit Shift.

As a disclaimer, I am a junior programmer. I have been programming for a few years but this is just the latest iteration of my current workflow. Open to any feedback or criticism

If you’re looking for much more senior advice, consider looking at BowTiedCrodile, BowTiedFirefox and BowTiedFox

Now that that’s out of the way, let’s talk about why you might want to keep some logs.

Personally for me, there are two main reasons I keep logs and that’s because they
(1) Improve your efficiency as a programmer and
(2) Help ensure that you can investigate errors when they come up.

Personally I divide my own logs into the following types of logs in increasing order of effort

1. Random scribbles

2. Old Code Snippets

3. Formal Documentation : Actual Articles, Newsletters OR Issue Documentation

Each serves a different purpose and to me, and as they move up the chain, my understanding of the topic ideally increases. Let’s look at them one at a time.

Random Scribbles

At my day job and when I’m working on side hustles, I often have a small notepad open to jot things down.

This might not be the case for everyone BUT i’ve kept my work notes and my personal side project notes separate on purpose from the start. I do this because

1. Work Environments are always tracked and you never know just what data is being extracted from the random .txt files lying around the system

2. I’d rather not risk randomly exposing some confidential data on a public cloud like iCloud or Google Docs.

AGAIN the chances of the two scenarios above are slim and a bit improbable but I think I’m just a bit more paranoid than most people.

Let’s walk you through an example of what this might look like - I took one of my older scribbles and updated some of the stuff in there with nonsense

....
event : morning standup (date : 12/34/67)
who is [redacted] and what do they do? What is the purpose of [redacted]

Ok seems like [redacted] has some issues - preliminary issues seem to be that
1. clowns are not showing up
2. Errors occuring at [location redacted]

TODO
1. Get signoff on [redacted] and get confirmation on bouncy castle
2. Coordinate with [redacted] on what's the best color for a clown nose

Created JIRA with issue of [redacted]

FROM <link to JIRA>

Action : Attempting to check in [redacted] environmet

Facing this error of

<error copy pasted from terminal>

Resolution : Turns out problem was []
...

In a day I normally take notes as I go along like this, copy and pasting little tidbits and writing a small diary of the things that I’ve gotten up to.

I learnt this from my original mentor at the first startup I worked at and It wasn’t until I started working that this habit came back in full force.

There’s a simple reason for this - you can’t remember everything so offload it into a cheap storage mechanism.

This is especially true when issues arise from things that you pushed into production 2-4 weeks ago and people need evidence that the problem was with the environment or what not instead of your code. I once pushed code that had an invalid deployment file into production - the code worked but the deployment script didn’t work as intended in production because I didn’t know I was supported to modify it.

Luckily, I had jotted my entire process down in a snippet and was able to locate

• The testing environment

• The logs file which documented my testing

• The logs file which demonstrated that the desired result was achieved by the code I had deployed

Without this small scribble of notes that I had written almost a month prior, I would have been in so much hot soup. If you aren’t keeping a small notepad to scribble these things down, I highly recommend you do.

I personally use OneNote for work stuff ( since microsoft comes shipped with most office computers ) and Bear for my personal stuff since it supports markdown neatly out of the box. The tool really doesn’t matter to be honest, just choose something and stick with it.

Code Snippets

Old Code is a love letter from your past self to your future self <3

This brings us to our second form of logs - Code Snippets

You will often find as a programmer that you’ll be re-using certain snippets of code no matter what domain you’re operating in. Ultimately there are some tasks which need to be repeated in different areas of your codebase and different projects.

What I like to do is to keep all projects I’ve worked on before on Github - but set their visibility as private. What this gives me is a nice UI to help look through some of my old code chunks and quickly filter what relevant sections I need.

Sometimes, I also include them with the notes that I’m taking. For instance, here’s an example which I pulled up from my notes on Airflow that I took sometime back

I’ve found that this is extremely useful - and you’ll find that the more projects you code up, the more this comes into play.

For those of you that want to do this at scale - you can consider looking at some alternatives.

• Front-end : Storybook ( Never used it but heard good things about it )

• Solidity Snippets : Cookbook.dev is a fantastic resources for any aspiring smart contract developer

• General purpose : You can consider using Masscode which is an open-source plugin with many native integrations into tools such as VSCode. I’ve never used it but am planning to experiment more with it in 2023.

Code snippets are a bit more targeted ultimately than just random scribbles because ideally they’re a bit more targeted than random scribbles - they’re meant to help you to save time instead of trying to go through an entire rabbit hole to solve a solved problem.

Formal Documentation

I group two different things under Formal Documentation - Articles and Issues. I consider these two different because the first concerns problems I encounter in personal projects/side hustles while the second concerns work-related context that i need to be able to access quickly.

Articles

When I encounter a problem multiple times or solved something that I’ve been working on for some time, I tend to write it up into an article. There are three main reasons for doing so

(1) It’s an extremely polished version of a code snippet with explanation for me to refer to down the line.

(2) It helps establish some degree of credibility

Ultimately you get paid not for your ability to regurgitate the different ways to invert a binary tree but for the experience that you’ve gained debugging and testing out your code.

A large reason of how I started writing Think Like A Programmer was because I wanted to consolidate my own understanding of data structures. I hadn’t touched these data structures for a while and I wanted to create a resource that would work best for me.

You can also find other articles at my website at https://www.bowtiedhamachi.com/articles. I haven’t been writing for a while due to other commitments but will begin writing more in a few more weeks hopefully once more things clear up!

Always host your articles on a publicly available domain unless you want to monetise them.

With Vercel you can get everything set up for less than 20 USD for 2 years of domain hosting so there’s not much stopping you.

If there’s enough demand, I can also release my own website as a template for readers who are looking to kickstart this article process. Just dm me on twitter at @BowTiedHamachi or email me at bowtiedhamachi@proton.me

But these tend to only concern problems that I’ve encountered on my own side hustles and projects. I cannot for instance, write about problems I’ve faced at my job while working on proprietary code base and frameworks.

Issue

If you’ve ever worked as a programmer at a larger scale firm, there tends to be a lot more structure in tracking things to be worked on and what you’ve accomplished. Where I work at, this comes in the form of the AGILE methodology - where every 2-3 weeks we sit down and plan out the tasks we want to accomplish.

This means that when we work on individual tasks, all of the code we push up is tagged to a specific Jira or issue.

You can check out Jira here . I personally don’t recommend the product though, very buggy and slow. Have heard good things about Linear so there’s also that.

As a result, whenever I submit code for review, I always make sure to add a huge comment so that I know what I’ve done for the task. This tends to take the following format.

Note : I don’t do this for my own personal projects as much since this is more to cover my ass in the event that something happens and I need to fix it within 2-3 hours.

I look to my random scribbles or articles for that.

# Testing performed
I logged into [redacted] and performed the following steps
1. Cloned repo from [redacted]
2. I imported in [redacted] configuration and restarted application
3. Triggered [redacted] 
4. Verified [redacted]

# Documentation of Tests
We can see that [redacted] is shown to have been applied via the following logs

[redacted] logs
```
...copy and pasted stuff
```

# Key Pointers
The new changes seem to have been applied when we run pipeline (url : link-to-pipeline) ...

Often times I will also add in and upload files to the git system that we are using so that I have everything on hand. I’ve often found that it’s better to over-document things rather than to under-document them. This way when anything happens you have everything you ned on hand.

Documentation

I tend to be a bit forgetful when it comes to executing steps - and this initially results in a lot of issues when I started working in production environments. I would always forget 1-2 things that I was supposed to do (Eg. change a variable name or update a specific value when running code locally)

Thankfully, at my company, we utilise a wiki provider where we can create pages of documentation. So, in my spare time, when I come across a problem more than twice, I try my best to write up a list of all the steps required for me to perform a specific task. I also try to add in as much images as possible of the steps so that the actions required are unambigous.

This doesn’t need to be complicated.

At the end of the day, all it needs to state is just

1. How to accomplish the task

2. How to verify the task

3. General guidelines/things to take note of

I’ve found this to be tremendously useful for myself - and for onboarding new hires when they join the team. A lot of time, people aren’t productive because they don’t have all the context - so having a wiki to put everything in place is just a useful step to help speed up the process.

Summary

I hope this was of use to you! I’ve been experimenting with my note taking system for many years and was a productivity geek who used to do everything from GTD to Kanban. Eventually, I realised that I just need to do two things

1. Keep the system simple

2. Reduce friction whenever an opportunity arises

If you’d like to try implementing something like this, I highly recommend starting with something simple - just use apple notes or even notepad++ as long as it is searchable and start noting down the things that you are encountering on a day to day basis.

Any feedback or suggestions on how I can improve are always welcome.

Main Focus

Hey all, welcome back to Think Like A Programmer - where we cover programming concepts in bite-sized chunks.

For those of you that celebrate the Lunar new year, I hope that you guys are having a fantastic time with your loved ones and family. :)

Moving on to today’s article, we’ll finish up our three part series on heaps - which are used to find the maximum or minimum elements of a list of elements in the fastest time.

This is a continuation of last week’s article where we looked at

1. How to represent a heap in memory

2. How to construct a heap from a list of elements from scratch?

So, what’s left for us to go through with heaps - The short answer is just the time complexity of the max-heapify operations that we mentioned the week before.

This requires a few concepts to be defined so let’s go through them one by one.

The runtime for this is a bit tricky so do try to stick with me as we go through this.

Pre-requisites

Before starting on the rest of this article, I highly suggest going through our previous articles on

1. Algorithmic Complexity - to understand what Big O Notation is

2. Binary Search Trees - to understand why a heap is not a binary search tree even though it looks like one

3. Arrays - to understand how index notation works when we use an array to represent our heap

4. Heaps Part I - to understand a bit of the context behind today’s article

5. Heaps Part II - to understand the exact operations that we’re working to find the time complexity of

Max Heapify Algorithm Swaps

Let’s go through a recap of the max-heapify algorithm one more time. Let’s assume we have the following binary tree of elements which we started with earlier.

This tree has a height which we’ll call h. In this case, it’s going to be 2.

Definition : The height of a heap is the number of edges between the longest downward path between a node and a leaf

We perform our operation only on non-leaf nodes since leaf nodes are valid heaps by default . If we encounter a leaf node (Eg. node 2 ), we simply move on to the next node. We can do so by performing two calculations to find the left and right child indexes, and determining if they fall within our heap.

But what if we encounter a non-leaf node? Well, then the number of swaps required will simply be equal to the level of the node.

We can see here that the nodes highlighted in blue above have a level of 1. If we wanted to balance the heap containing 2,4 and 3, we would need at most one swap.

Read more

Apologies to anyone who might have received a new email today called What to Expect from this newsletter - I was editing some things in my first newsletter Article and accidentally sent it out.

Welcome Back to Think Like A Programmer, where we break down complicated computer science concepts into bite-sized articles for you.

In today’s article, we’ll continue looking at heaps - which are used to find the maximum or minimum elements of a list of elements in the fastest time. This is a continuation of last week’s article where we looked at

• Why use a heap?

• How to add items to an existing heap

• How to remove items from an existing heap

Before starting on the rest of this article, I highly suggest going through our previous articles on

1. Algorithmic Complexity - to understand what Big O Notation is

2. Binary Search Trees - to understand why a heap is not a binary search tree even though it looks like one

3. Arrays - to understand how index notation works when we use an array to represent our heap

4. Heaps Part I - to understand a bit of the context behind today’s article

So, what’s left for us to go through with heaps?

The short answer is that we’re left with 2 big concepts pertaining to heaps

1. How to represent a heap in memory

2. How to construct a heap from a list of elements from scratch?

We’ve gone through a few different data structures in the past few weeks, but not all of them will be appropriate for us to reap the benefits of a heap. Let’s go through them one by one.

Can we use a Linked List? If you’ve forgotten what these are, you can read our article on linked lists here.

Immediately, a glaring problem jumps out at us - our heap parent nodes have two children each, but our linked list nodes only have space for …. 1 ? That means that we won’t be able to use our linked lists at all for heaps.

The same problem applies when we stretch for Stacks and Queues - these all have capacity for at most 1 child or none.

Well, how about using a binary search tree then? That way, each node can have 2 children.

While that does indeed solve our original problem of having enough space to store a reference to 2 children, we have a new problem - finding any element takes at worst O(n) time since we never have a guarantee that our binary search tree is balanced.

If you’re not sure why the worst case scenario is O(n) , revisit our article on Binary Search Trees here. If you’re not sure what O(n) is, then revisit our article on Algorithmic Complexity here.

This means that even before we can perform our insertion or deletion algorithm, we already incur a cost of O(n) steps at worst.

So, what’s the solution here? Surprisingly, it’s an array - or an dynamic array if you want a heap to be unbounded in size.

Let’s build some intuition for why this might be the case.

Heaps

Indexing Heaps

If you’ve forgotten what a heap looks like, here you go.

Quick Recap : Is this a max heap or a min heap? Don’t scroll down until you’ve made a guess as to what it might be

The answer is that, it’s a min heap! This is because of two reasons

1. Order : All parent nodes are smaller than or equal to their child nodes

2. Shape : All levels, except for the last level, are completely filled.

As a result, we have a min heap. If we were to index the elements from 0, starting from the root node, we would get the following indexes.

Interestingly, if we have the index of a parent node, we can calculate the indexes of its left and right child using the formula seen below. Note that i is the index of the parent node.

left = 2*i + 1
right = 2*i + 2

We can verify this is the case by trying a few examples

Parent = 0
left = 2 * 0 + 1 = 1
right = 2 * 1 + 2 = 2

parent = 1
left = 2 * 1 + 1 = 3
right = 2 * 1 + 2 = 4

Read more

This sounds very … limited and you’re not exactly wrong if you think that way. When I first learnt about heaps, I thought that they were rather useless. After all, why care about finding the maximum or minimum element in a list of elements when we could just sort the list or just traverse the list to find the largest/smallest element.

Before starting on the rest of this article, I highly suggest going through our previous articles on

1. Algorithmic Complexity - to understand what Big O Notation is

2. Binary Search Trees - to understand why a heap is not a binary search tree even though it looks like one

3. Arrays - to understand how index notation works when we use an array to represent our heap

So, why use heaps?

The short answer to that is heaps can help us find a maximum and minimum element in a constant amount of time - since this is always the root node. Even when we add in a new element or delete existing ones, we will only need O(log(n)) time to rebalance the heap.

Fun Tidbit : I found this interesting Quora answer when trying to find some real-life applications of heaps : https://www.quora.com/What-are-some-real-world-applications-of-a-heap-data-structure, worth a look!

If we were to use a traditional array or linked list, we would have to use O(n) since we would need to go through every element in the array, perform a comparison. When we add or delete elements in our array, this runtime doesn’t change.

Here’s a quick graph to visualise the difference between log(n) and n as the size of n increase from 0 to 1000 elements. It’s quite drastic to say the least, with the difference growing significantly as the number of elements grow.

I hope this has piqued your curiosity about heaps - so without ado let’s start delving into them.

Note : In this article, we’ll be covering binary heaps only. We won’t be covering heaps with more than two child nodes since they are out of scope for this topic and a tad bit more complex and rare.

We’ll be looking at an implementation of a heap using arrays in the following weeks - this week is just a high level overview.

Introduction

Parent Nodes and Child Nodes

Two weeks ago, we covered Binary Search Trees - where we look at the nodes that look like what we have below.

If we were to designate 56 as a parent node, then 30 and 70 would be its child nodes. If we were to blow up our binary search tree and add a few more elements, we can see that there can be multiple parent nodes in the same tree.

This makes sense since parent and child nodes are just terms we use to identify a relationship between individual nodes. This is an important concept to understand.

Applying this to Heaps

So how does this apply to a binary heap?

Read more

Personally, I think graphs are extremely useful in computer science - and they’re probably significantly more useful than you think!

Analogy

Imagine you’re going to a new theme park and you see the following map

We can mark out potential places of interest with a circle as seen below. In this example, I’ve chosen 5 random places and marked them out.

There are also some roads that connect the individual attraction so let’s use some lines to represent these roads

Each line here represents a direct path that connects the two nodes without going through another attraction

Now that we have this specific representation, what can we do with it?

Read more

Before starting on today’s topic, I highly suggest looking at our previous articles on

1. Arrays

2. Linked Lists

Analogy

Ever tried finding a book in a unsorted bookshelf? It’s pretty hard to find anything at all if the books aren’t sorted out nicely at all.

Most times, you’ll need to sieve through the books one by one until you find what you’re looking for and if you happen to accidentally gloss over the book that you want - good luck starting from the top.

That’s why most bookshelves are sorted out in a alphabetical order - you have the books that start with an A before those that start with a Z.

As we covered in our previous article on comparing algorithms, having an alphabetically ordered list of books means that we can reduce our search space.

Intuitively, If we’re looking for a book with a name that begins with a M, we’re not going to start looking for the book in the section with books that begin with Z.

What happens then as our collection of books gets larger and larger? Well, the most intuitive thing then is to simply start categorising collections according to subject. Each collection is then sorted alphabetically.

Read more

In the past few weeks, we’ve covered a good amount of ground - algorithmic complexity, arrays and linked lists just to name a few. If you haven’t checked it out, I suggest that you give them a quick read.

This week, we’ll look at queues - specifically why they’re important and how we might be able to implement them. We’ll cover an analogy that showcases how they might be useful before looking at some of their real-life use-cases.

Story

You’re the owner of a big and popular bakery in the middle of town and you’ve got a problem - too many customers.

Before you know it, the store is overflowing with customers everyday and people are getting annoyed. Sometimes it takes minutes to get a delicious brioche while other days it takes hours to get their fix.

To make matters worse, your staff tend to get overwhelmed with the people screaming at them for their orders. They frequently get the order wrong and customers are understandably frustrated.

The service isn’t consistent in terms of quality or process.

Single Queue

One day, you get the bright idea to implement a queue - everyone gets themselves a queue number when they arrive in the store and that determines the order that they get served in.

In a queue, the first person to join the queue is able to get their order served first. In other words, the first person in the queue is the first person out of it. Queues are therefore an example of a First In, First Out (FIFO) data structure.

If we used a stack based approach like we covered last week, then we would probably get significantly more customer complaints :/

( Excuse the poor drawing below )

The new flow helps tremendously and customers are now served in the order that they come in. As long as they get a queue number, they can roughly estimate how long it’ll take for them to get their order.

Because you’re now serving customers in a fixed order, you can now afford to take some time with each order and wrong orders are soon relatively rare. This allows you to start noticing that some of your customers only order your sourdough loaves, nothing else.

Separate Queues

As a result, you decide to run a small experiment and set up a separate counter that only sells sourdough loaves. This results in a new setup as seen below where a separate queue is provided

After running this experiment for a few weeks, customers are now happier because wait times have decreased. They can now get their bread quicker and not have to squeeze and jostle like in the past.

Read more

Before starting on today’s topic, I highly suggest looking at our previous articles on

1. Arrays - For a quick overview on how memory works under the hood

2. Linked Lists - For an idea of how we can efficiently work with memory when we’re not sure of the amount of items we’d need in advance

before proceeding. This will ensure that you get a good understanding of what benefits a stack brings to the table and why it’s used so frequently in a variety of different languages.

Analogy Time

If you’ve ever tried to cook a dish, you know that things rarely go to plan. Let’s take a simple omelette for example. Every recipe normally goes something like this

1. Crack some eggs and put them into a bowl

2. Heat up a pan with medium heat and throw in a generous stick of butter

3. Pour your egg inside

4. A perfect omelette is born

However, what normally ends up happening in my case, is that

1. Crack some eggs

2. Realise that I’ve dropped some egg shells into the bowl

3. Find a small spoon in the cupboard

4. Try to scoop out some of the egg shells

5. Rinse off the egg whites on the spoon

and so on…

Read more

Hey there, hope you’re having a good thanksgiving no matter which part of the world you’re in.

If you’re still on the fence about subscribing, gentle reminder that we’re holding a thanksgiving promotion that ends this Sunday. We’ve got a lot of good articles coming up in the next few months - from data structures, to front-end programming and walkthroughs on programming challenges.

Get 20% off for 1 year

Before starting on today’s topic, I highly suggest looking at our previous articles on

1. Arrays

2. Linked Lists

3. Comparing Algorithms

4. Interfaces

This will ensure that you get a good understanding of what benefits a dynamic array brings to the table and why it’s used so frequently in a variety of different languages.

Summary : The intuition behind a dynamic array is really simple - the moment we reach a certain capacity limit, we expand.

Traditional vs Dynamic Arrays

Let’s start by creating a little array with enough space for 4 elements. Notice that it currently only has 3 elements.

The moment we add a fourth element into our array, we’re out of space.

Traditional arrays cannot be resized. The moment you use up the array’s capacity, you’re done. But that’s where dynamic arrays come in, you simply allocate more space and copy the original elements over using the following steps before inserting in the new element.

Read more

It means a lot to me that there are people willing to subscribe and read my weekly articles and I appreciate every single one of you. I had been debating whether or not to do this newsletter for the longest time and I’m so glad I took the plunge.

We’ve got a lot of high quality posts coming over the next few months and a paid subscription will give you access to all of them. If you’ve been debating whether or not to break into tech, I’m confident that the articles will give you a solid foundation to beat out the competition.

This week’s post will drop a little later due to the thanksgiving holiday but look forward to another high quality one.

In light of Thanksgiving, I’ve added a 20% discount which will run till this weekend.

Get 20% off for 1 year

Have a great thanksgiving ahead!

Introduction

Hey there Anon, welcome back to Think Like A Programmer. In this week’s article, we look at the difference between an interface and a data structure. Many people confuse the two and clearing up the difference between the two is vital.

For the past two weeks, we covered two different data structures - Arrays and Linked Lists. If you haven’t read them yet, I suggest that you check them out so that the subsequent section of this article will make more sense.

Interfaces vs Data Structures

To put it simply, an interface is the list of operations that we can perform. A data structure on the other hand, is the implementation under the good to make those operations possible.

To make this point more explicit, let’s consider a more abstract example.

Let’s imagine that you invent a messaging system so that you can keep your colleagues updated with what’s happening in the latest projects.

This system needs to allow you to do two things

• send a message

• receive a message

This is its interface.

Now there are many ways that we could implement it but let’s look at two possible ways.

Manual Labor

We could implement this with some help from some unfortunate victims in the following manner.

Let’s imagine that the office has 4 tables like the image you see above. The tables are far enough that you can’t shout to one another whatever you want to say. So, whenever you want to send a message across to your colleagues, you

1. Call a messenger over

2. Hand him your note

3. Watch as he runs over to the table of your choice

With that we’ve implemented a way to send messages.

Receiving messages is relatively straightforward - if you see someone running towards your table and calling your name, you’re about to receive a message.

Read more

Hey anon!

It’s been a while since I announced the new paid Substack. Today’s drop marks the fourth paid article in our Substack.

As usual, we're still running the 7 day free trial promotion that will allow you to get access to the content below which will give you a quick glance at what is on the way. This will end soon so do seize the opportunity to check out what’s behind the paywall~

Intuition

Today we're back with another metaphor for a linked list. Hopefully, after this longer story you'll be able to get a better idea of what a Linked List is. This follows our previous two articles on arrays and comparing algorithms and builds upon them.

If you haven’t checked them out, I suggest reading through them to get a better handle of what this article is about.

Books Galore

I love reading books and my book shelf is always bursting with a whole lot of books. I can't take a picture of it but it looks somewhat like this.

With only a few shelves, I started to run out of space pretty soon. This meant that soon, my tidy book shelf went from the nice and tidy space that I have to a messy makeshift arrangement with boxes and boxes on the floor.

I quickly realised that I needed a way to store this rapidly growing collection of books. The problem wasn’t going away but I figured I could at least store the extra books in one of the rooms in my house - in this case, room 3 is empty so we just throw it into the room.

It’s a pretty big house and sometimes it’s rather difficult to keep track of everything in each room. So I decide to write up the room number that the box is stored on in a stick note and stick it on the shelf.

Is it a little messy? Yes. But at least I don't need to buy an expensive new wooden shelf which would cost me as much as all my books combined.

pardon my bad drawing but that box with the arrow pointing elsewhere is in-fact a sticky note with the words Room 3 on it to indicate that the box is stored in room 3.

Pretty much not too long after that, another box gets filled up and we chuck it in another room since room 3 is quite small.

Read more

Hello anon!

It’s been a while since I announced the new paid Substack. Today’s drop marks the third paid article in our Substack. I’ve also added a 7 day free trial that will allow you to get access to the content below which will give you a quick glance at what is on the way.

Intuition

I’m experimenting with a bit more of a simplified story to get the point across here. Slightly more technical explanation is provided after this section.

Big Pile

Let’s try to build our intuition for algorithms by thinking about finding a book in an imaginary library.

Recall here that an algorithm is simply a series of steps that we perform to get a result. You probably use all sorts of algorithms in your daily lives, even spreading peanut butter on a piece of bread involves an algorithm!

Now the librarians are lazy and have unfortunately thrown the books onto the floor. They’re piled on top of one another and you have no idea what books are in the pile, much less whether or not your desired book exists in this pile.

If you were looking for Dancing Dragon, then you’re in luck because it’s right on top of the pile of books. But if you were looking for A Big Journey, you would have to search through all the other books in the pile to find it lying at the bottom.

This means that at best, we have a single action to perform - picking up the book. But at worst, we have to sift through every single book in the pile. If we had 10 books in the pile, we would need to sift through 10 books. If we had twenty books, we would need to sift through 20 books.

Read more

Hello anon!

It’s been a while since I announced the new paid Substack and I’ve been rewriting and re-organising a lot of the content so that I feel comfortable publishing it as a paid article.

Today’s drop marks the first two paid articles in the series and I hope you like it. I’ve added a 7 day free trial that will allow you to get access to the content below which will give you a quick glance at what is on the way

Keep Reading with a 7 Day Free Trial

Subscribe to Think Like A Programmer to keep reading this post and get 7 days of free access to the full post archives

Get 7 day free trial

Read more

Introduction

This is the second paid post in this substack’s history! We’ve got a good amount of content lined up, especially for data structures and stay tuned for more good content to come.

I’ve added a 7 day free trial that will allow you to get access to the content below which will give you a quick glance at what is on the way

Keep Reading with a 7 Day Free Trial

Subscribe to Think Like A Programmer to keep reading this post and get 7 days of free access to the full post archives

Get 7 day free trial

Read more