Lately, I've been exploring the idea of simplifying my life by subtracting rather than adding. This journey began with the book Please Unsubscribe, Thanks! and was further inspired by Subtract by Leidy Klotz. In this post, I'll focus on subtracting projects I've started over the past years, in a future post, I'll write about financial, physical, and other areas of my life.

This is a good time to share that I started working full time again. I joined as a web developer at a company called Numeral. They're a small startup focusing on making taxes easier for online stores. I'm really enjoying working with the people and the tech stack. Because of this new change in my daily life, how I was structuring my days and time overall has changed a lot.

Previously, I would start projects that popped into my head. I would work on them for a while to see if they had potential. If they did, I'd continue; if not, I'd move on, despite feeling disappointed about the time invested.

The issue was and the reason I'm posting this is that they all sort of lingered or more like languished in the background and in the back of my mind while I worked on other things. This has been a sour feeling as it leads me to hoard unrelated projects and I don't want to start new ones because there's so much I would like to get done on my previous projects.

It's a Monday and I have the day off so I decided to use this time to help my mental state my clearing out some of these old and unused projects. It's going to be mostly tough for me but I think making a semi-public post about it would push me to really get rid of them.

Let's start with the oldest projects first:

1. Bookends. My forever neglected project, this is like my precious baby that I never want to get rid of but I also never pay enough attention to to make any progress on it. I think it's time now, after almost 6 years to give this up. The domain was registered in 2018 and ever since then, I've worked on many versions of this project. I've learned a lot of web development skills especially with node.js using this and most recently learned next.js with this project too. For now, I don't see it ever taking priority and I think it's best I say goodbye to this one. An alternative to Bookends I've found and have loved using so far is Italic Type.
2. Treat Samples: this is a pretty cool domain I got as a dot com but I think it's best I don't spend more time on this one. My initial approach with this one was that I build an ecommerce store that focused on putting together treat samples for pets. I was trying to scratch an itch I had and I thought others would too which is that there are just so many treat options out there but no real way to sample them. A pack of treats can be anywhere from $10-20 which is pretty expensive if your pet ends up not liking it. The way I wanted to approach this was by offering a $10-15 sample pack with almost a dozen treats in them. The issue was that I didn't want to deal with all the treat packing and putting together packs. This one is an easy one to let go of because I wasn't too connected to it.
3. Wildwood Pixels: while I was on my sabbatical, I wanted to test my appetite for running a web development agency. The very short summary of this is that building your own agency from scratch, with no clients and no sales skills is really tough. I tried to get a few clients and work on some projects but nothing amounted to real paying work so this one felt very short-lived and I got very uninterested because it really felt like a chicken and egg problem, I didn't have projects I can show off so I couldn't convince anyone to let me build stuff for them.
4. NextJig: since about October, I have been attempting to build a place for contractors and homeowners. The biggest differentiator for this project compared to what exists out there is surfacing information that is already required for certified contractors e.g. licenses. I made pretty good progress on this, I also had some real people interested in using it but the homeowners' side of this was way tougher to convince someone to give this a chance. With this project, I learned a lot more about Next.js and building a working app using all the other tools in the ecosystem. I loved building this project but for now, I am subtracting it from my life to make time for other things.

These are the four main projects I'm leaving behind and opening up my mind to new things along with focusing more on work during the week. In January, I was learning iOS pretty seriously and I think my new next few projects will be focused on building iOS apps for fun, and maybe for profit in the far future.

Subtracting these projects from my life is a bittersweet process, but it's a necessary step towards focusing on what truly matters and embracing new opportunities.

For the past few years, I've been doing this thing where at the beginning of every year, I take a hard look at my subscriptions and decide if I should consider canceling or continuing to subscribe, and in some rare case, start subscribing to new services. I want to share my list below and figure out what the total is and maybe this will give you inspiration to take a look at your services too!

Subscribing

First let's look at new services I'm adding to the list this year:

• Obsidian Sync, this is $10 / month. I have been using Obsidian for over a year but recently I've really used it! I use it for writing posts like these, for organizing work, for jotting down quick notes. It's becoming a full replacement for all my notes apps.
• Kagi, $10 / month. Search should be good, Kagi makes search great. No ads, no SEO bullshit, and I love the customization options.
• MacroFactors, $80 / year. I use this app for tracking food. This has been helping me gain my weight back. It's also one of the best UX when it comes to tracking food.
  I'm adding about $27 / month of services to my list of all services (see below).

Canceling

• The first service to get the axe this year has been Youtube Premium. I was using it a lot but we were paying the $30 / month price that is charged if you pay through the App Store. It's plain malicious that they charge 30% more just because you go through the app store, blame Apple, blame Google, it doesn't matter at this point. I was able to get rid of this by joining my brother's family plan (I added him to my Spotify plan).
• SimpliSafe. I was never using their cloud features that cost $10 / month.
• Hulu. This is an expensive service that I was only using once in awhile, at $17.99 a month it's an easy one to let go.
  In total, I'm canceling about $58 / month worth of services this year. This is exactly double of what I'm adding this year so I think this was a good list of services to get rid of.

All services

At almost $270 / month, this list is pretty pricey. The two exercise services and the extremely expensive Netflix are under my radar for this upcoming year. Let's hope it doesn't get much worse next year.

It's our annual snowstorm in Portland, a week where the whole city just shuts down and braces for the snow. We got snow on Saturday (Jan 13th) and today's Thursday and there's still snow on the ground.

Here's the temperatures for the past few days:

The days after the snow, we stayed under freezing temperatures which made things unbearably cold and on Tuesday, Jan 16th, we got some hail and rain which froze overnight. That frozen rain created a layer of ice on top of the snow which is pretty much the slippery thing I've ever experienced!

Below's a video of me trying to walk in those conditions:

This year made me realize I need the following things for the next year:

• Some salt to put on our stairs and other high traffic areas around the house, like the steps on the deck in the back.
• Get something with traction for my shoes
• Have a snow shovel

When I signed up for Fastmail a few years ago, I decided to keep my inbox as clean as possible. Not just zeroed out but also never getting any emails that were not important or useful to me. The majority of these emails were marketing emails and newsletters.

Some marketing emails, I care about, for example I love Tailwind and I'm excited to see updates from the team so I am interested in their emails. But some make their way into my inbox without my knowledge, a lot of these are related to places I shop.

Most of these emails, I just delete or ignore but every once in awhile, I'll run into an email that just bothers me so much I have to unsubscribe.

For instance, I got an email from MyFitnessPal that just had images of food with text like "get energy that lasts" or a person drinking water with the text "lose weight". Clearly this email is not for me, it's for a marketing list, I joined MyFitnessPal with the goal of gaining weight and I don't even use the app anymore.

So for emails like this, I first look for the "unsubscribe" link. Oftentimes, clicking the link does it. But once in awhile, some person has designed the unsubscribe flow in a very dumb way, it asks for the email again and when this happens, I go back to the email and specifically mark it as spam. This usually doesn't do much but I hope that at some point, these emails will not show up in my inbox.

So to simplify the rules:

1. If the email contains an unsubscribe link, I click it and then that's it.
2. If the email's unsubscribe link doesn't automatically unsubscribe me, I mark the email itself as spam and then go through the unsubscribe flow.

I love mechanical keyboards, I have been obsessing over them for more than a decade and every once in a while. I write about keyboards here but I felt like the content I want to write about isn't as personal and oftentimes just content I want to have on the internet. This blog is sort of a mishmash of things already but I wanted to separate out the focus for keyboard related into its own place and go deeper into the topic of keyboards.

You can go see it below:

I would love to take this initiative seriously and write once or twice a week about topics related to keyboards and if you want to follow along, I'd appreciate that very much!

This year started out very differently than how it is ending, and I wanted to jot down as many of my thoughts as possible before I get busy with the new year's energy. I want to share an overview of my current health, how it has changed over the last year, and what it means for me going into the next year.

A Retrospective on 30 Years of a Mildly Healthy Lifestyle

I am lucky to have lived for over 30 years with no major health issues, eating a moderately healthy diet, and exercising at a below-average rate. Surprisingly, this lifestyle served me well, but that's all changing now. Being active was easy when I lived in San Francisco, where riding my bike, walking around, and going on short hikes helped keep my heart healthy and my weight under control. For most people, gaining weight is not just easy but inevitable. I have been blessed with a combination of genes that has prevented me from gaining weight, even during times when I wanted to. Not having excess weight helped keep my body functioning healthily, but I think it also created a blind spot for me. I didn't see my unhealthy habits, like eating too much greasy food or going a whole day without any food. During the pandemic, my health became less of a priority, as working from home required a lot less physical activity, and fear of catching COVID-19 limited my outdoor activities.

A Change Long Overdue

Over the last 5 years or so, I had been experiencing minor stomach pains, often attributing them to unhealthy eating or suspecting undercooked or contaminated food. It turns out, these factors were not the main issue. Underneath it all, I was developing ulcerative colitis (UC), an autoimmune disease with complex, not fully understood causes, involving genetic predisposition and environmental factors. You can read more about UC on Wikipedia.

How Did This Happen?

I wish there was an easy answer. The past decade of my life has been full of stress, changes, life events, and many unpredictable things, as most people's lives are. With all these variables, it's hard to pinpoint a specific cause for my UC. Unhealthy eating habits, stress from work, excessive coffee consumption, and irregular eating patterns certainly didn't help, but it's impossible to single out one thing as the definitive cause. In September, I started to have very strong stomach pains and it led me to spend a lot of time on the toilet too and this became a concern that first took me to urgent care and eventually to the ER. A few days in the ER revealed that I indeed did have UC and need to start addressing it.

Today, End of 2023

It's December 29th, with just two days left in the year, so I wanted to capture what I'm feeling and what my next steps will be. Today, I had a follow-up appointment with my doctor, who gave me extensive details on how ulcerative colitis will affect my life and what I should and shouldn't do. I was prescribed a new medication, mesalamine, which hopefully will help with the colon inflammation. For the past few weeks, I have been following a low FODMAP diet to avoid irritating my gut. It wasn't showing significant changes but was helpful in identifying foods that irritated me. From the various blood and stool tests I've had over the last few months, here are a few things I know to be true:

• I don't have celiac disease. Eating gluten and wheat products should be safe for me.
• Dairy does not negatively affect my gut. Eating a balanced amount is advisable.
• I'm low in iron and vitamin D3, and high in calcium.

Thalassemia Minor

Almost 5 years ago, a 23andMe test suggested that I might have a genetic disorder called thalassemia minor, which was later confirmed through blood tests. This minor disorder has been a challenging part of my life, causing extreme fatigue and occasional lethargy. With recent hospital visits, I was advised to take iron supplements and vitamin D3 to help with my energy levels, under medical supervision to avoid complications associated with thalassemia. About a week into taking these supplements and eating more regularly, my energy levels have been some of the best I've remembered in recent years.

What's Next for 2024

I'm looking at the new year with hope and positivity. First, I want to focus on improving my habits, health metrics, and lifestyle. Habits like exercising and being mindful, which were secondary to my daily life, are now primary activities I need to engage in every day. To measure and improve these aspects, I'm noting my current metrics and aiming to enhance them over the next 12 months.

Heart Health

The main health metric I want to improve, as it has taken a downturn, is my heart rate. The best overall metric I've found to measure this is my resting heart rate (RHR), which had an average of 65 BPM over 2023. It has been increasing over the last few months, mainly due to reduced activity, increased stress, weight loss, and dehydration. I'm ending the year with an average RHR of 72 BPM, which is higher than last year's average of 61 BPM. I'm aiming to lower my RHR below 60 BPM in 2024. This will be a challenging goal, but with the right steps and consistency, I believe I can achieve it. Improving my heart health will be the biggest benefit to my overall well-being, as it's a crucial aspect of health that cannot be ignored.

Weight

My weight has gone down from 140 lbs in September to 123 as of a few days ago. This has been due to the UC symptoms and dehydration. My goal for 2024 will be 150 lbs and that's going to be a stretch in all cases but I want to push hard and see if I can attain that.

Please note, the content in this post reflects my personal experiences and should not be taken as medical advice. Always consult with healthcare professionals for advice tailored to your individual health needs.

The past week has been a valuable exercise in discipline, pushing me to write and learn more frequently. However, I've come to the conclusion that I was devoting too much time to these activities rather than building and experimenting.

This post touches on the above, but it primarily explores what's been happening around and within me.

I plan to write a detailed kitchen repair and remodel post once the remodeling is complete. However, I believe it's important to address this in the current post. About 3 ½ weeks ago, we had a water leak in the kitchen and since that day, we've had less and less access to a working kitchen. The first week felt a bit crazy with a water damage mitigation company being in and out every day to get the place dried but after about a week of that, we got the kitchen demoed which left us with no counters, no sink, and a hollow room with nothing but plastic sheets covering it. With each passing day, it felt more and more like we're camping in our own house than living in it. No running water on the main floor and no sink to easily go rinse your hands or dishes.
Naturally, this led to a depressing feeling of not being at home while being at home. So, part of this post is writing about what a mental strain it is to not have a living space that feels "normal". I've been feeling overwhelmed by it and of course, I'd feel even worse if it wasn't for Kristen's help in pushing through a lot of the planning.

The other thing I want to write about is a holistic overview of what's going on within me, my mind and my body. There are numerous studies showing a relationship between the gut microbiota and mental health [1, 2, 3, 4], and for me this has become a jarring reality I've been dealing with over the last month. Right before I got back home from Idaho last month, I had been feeling an increase need to run to the restroom and I thought it was just a matter of having eaten something bad that was bothering my stomach. Well, over the proceeding weeks, this situation got worse and worse to the point where I had to go to the doctor and get checked.
Over the last 6-7 years, I've gone to the doctor at least once a year to get blood drawn. This all started with a 23andMe genetic marker mentioning that I might have thalassemia, which is an inherited form of anemia caused by faulty synthesis of hemoglobin. The blood results confirmed this and in short, it meant I should definitely not have kids with someone carrying this gene as well. But as the years passed, the anemia started to become more prominent and recently with the gut issues, it has been causing me to feel pretty tired midway through the day. At some point in the afternoon, I will want to just lay down and sleep. The reason this has become even more of an issue is because I've stopped drinking coffee as my morning drink due to the gut issues. According to the doctor, so far, I have nothing serious to worry about with my gut, it might just be my colon trying to heal from stress and bad foods. In an effort to promote gut health, I've decided to reduce unnecessary external or self-imposed stressors.

Being active by walking and exercising is high on my list. Next is watching what I eat, trying to consume whole foods with enough iron to support my body's lowered ability to hold onto it. And of course, getting adequate sleep.

Taking care of my body will hopefully lead me to building some useful and fun things but at the moment, I wanted to write about these two things on my mind because they're affecting me immediately.

Moving on to projects and ideas I have been experimenting with, the last month has been spent in a sort of wandering place within my mind, no real concrete ideas or projects have been done and over the last few days, this reality has become more jarring and scary for me. Not building something, not having an active project always makes me feel like I'm not doing enough. But I think using this break in building has led me to realize that I should narrow my focus onto one specific thing and stick with it longer. Build towards a goal, build over the bumps and roadblocks, and hopefully put something good and useful out there.

Over the next few days (and possibly weeks), I will be cutting down on things that take away my focus and eat away at my time and see where I am at by the time the kitchen is ready to go which won't be until late November.

Today, I'm at Eastside Coffee Bar & Workspace. It's a nice little coffee shop with a bunch of seating available to sit and work. I am not at my house because I wanted to get away from the noise of plumbing work that started today.

I'm focusing on the basic primitive data types. This is one of those topics that is part of every programmer's foundational knowledge but I think reviewing and going deeper into these can't hurt anyone.

Data Types

First we'll focus on primitive data types. They're called "primitive" data types because almost all languages implement these data types at a core level, whether through the base language or through an almost always included standard library.

Booleans

The simplest and one of the most useful data type, the humble boolean. Values can either be true or false. Depending on the language, they might be all lowercase, capitalized, or all upper case. In Python, they're written as True and False. In C, C++, Javascript, Java, Ruby, and a bunch more, they're written as true and false. In FORTRAN, they're written as TRUE and FALSE.

Moving past just how to write booleans, what are they useful for? Well, almost everything. To me, they're a parallel to computer hardware because everything at a fundamental level like transistors, RAM, CPU, and control flow is managed by ones and zeros. Since bits exist as either a 1 or 0, a boolean only needs one bit to store it but as most modern computers use a minimum of a single byte to store any data, booleans are stored in a byte.

Booleans are so very useful in helping the flow of programs, e.g. when writing a conditional.

Numbers

I didn't want to call this section Ints or Floats because at a human level, we're talking about numbers and how they're stored and interpreted by the computer. Oftentimes, most languages will implement two main types of numbers: Integers and Floats.

Integers are whole numbers without the decimal place like 2, 5, 420, 5000 or any other number you can think of.

And Floats are numbers with a decimal place and how precise you want the number to be becomes relevant, these could be things like 97.0, 1.234, 3.14159..., 2.5. Since all data types use space in memory, early implementations of numbers were intentionally done to accommodate most human applications of numbers but not insanely large numbers.

Aside on signed vs unsigned: I've avoided this part so far because it's a detail that matters in some programming languages but not all. In a language that use signed and unsigned integers, they use one bit to allocate this distinction. When an integer is signed, it can be both positive and negative numbers but when it's unsigned, it can only use non-negative numbers (zero and all positive numbers). So for a typical 4 byte integer, it will have 32-bits worth of space to store a number and if it's a signed integer, that would take away one bit to use for the sign (positive or negative) and leave the remaining 31-bits. Not all languages support signed and unsigned integers.

Strings

The next data type we'll look at is the string data type. This can be used to store all kinds of characters as long as they're wrapped with quotes, single or double. Examples are: "hello world", "an emoji 😊", and even numbers "1 apple, 2 bananas, 3.14 pies". As humans, we need to use strings pretty often but for some languages like C, strings aren't even available in the standard library, only a char data type is available which is a single-character string.

Today's topic is pretty straight forward. I got this one from the list of concepts that ChatGPT suggested. I think on days when I'm short on time or feeling less inspired, the generated list could be useful.

Sidebar: today I am feeling a bit underpowered because I went to get my blood drawn. More on this in the future as I find out more information.

What are hash tables?

A hash table is data type that uses keys and values to create associative arrays or in some programming languages it's known as a dictionary or hash map. The important difference between a basic associative array and a hash table is the hashing function which makes the lookup times much faster than if you used a generic array and created an associative array from it.

Python is one language that I know has a dictionary implemented in the standard library, I'm sure there are many others that do it too. Below is an example of what that should look like:

coordinates = {"latitude": "45.523064", "longitude": "-122.676483"}

print(f"Portland is located at {coordinates['latitude']} × {coordinates['longitude']}")

In this example, I'm using a simple lookup to get the latitude and longitudes of the coordinates dictionary.

What is hashing?

Hashing is the important part that makes a hash table good as a data structure. A hashing function is used to convert a given key within the hash table to a unique index. This indexing allows constant lookup times which means that the size of the hash table does not matter as long as there is enough space for indexing of the keys.

How is a hash table different than an associative array?

According to my internet searching, it seems like in most cases, they're the same. But the important terminology difference lies in which context they're being used in. An associative array is usually an abstract concept and can be implemented using a hash table or a regular array, one that does not have a built in associative functionality. The term "hash table" is used to refer to the data structure that includes a key-value relation and includes a hashing function, in the context of computer science it's used as a catch-all for all the various names programming languages use like Object (JS), dictionary (python), HashMap (java), Hash (ruby), map (go), std::collections::HashMap (rust).

Conclusion

The good thing about today's learnings was that now I know that when people refer to maps, hash tables, associative arrays, they're usually the same aspect and do not really differ much, mainly the naming and programming language are the major difference. I didn't know about the hashing function which is seems to be the magic in all hash tables.

It's the weekend and I didn't have much free time today so I'm covering recursion.

Recursion is an important topic in programming that often gets looked over because oftentimes it's used in self-evaluating algorithms. But before I go into Opinionland, I'm going to define what recursion is.

What is recursion?

I really like the Wikipedia definition of recursion even if it's sort of confusing:

Recursion occurs when the definition of a concept or process depends on a simpler version of itself.

Ok so what does that mean? To me, it made sense once I looked at an algorithm that uses recursion, inside merge sort. But let's define things that make up a recursion so that it's a bit easier to understand.

Recursion contains:

Base case: think of this as a step that the function has to take or else it will have not-so-fun consequences (more on this soon).

Recursive step: this step is one that seemingly just calls itself based on a condition that doesn't send the function into another call to itself.

Here's some pseudocode that might explain this too:

function recursiveFunction(parameters):
  if baseCase is true:
    return something
  else:
    someValue = doSomething(parameter)

    return recursiveFunction(someValue)

Let's take this line by line:

1. We define a function called recursiveFunction that will take parameters as the argument when called.
2. A – We check the base case and if the conditional checks to be true, we return something. Here, something can be some calculated value or just the same value passed into it.
   B – If the base case is not true, then we do the following:
3. Calculate some value from doSomething which should do something like modify the value, get some resulting thing, because this will become useful next.
4. We run the recursive function again and just pass the value we just got from doSomething.

If you didn't cause any issues that would never hit the base case, you should be good to go. If you didn't catch your base case, then your function will run over and over forever–or until you kill it.

That seems to make sense to me. Now, I'm going to log off and test this tomorrow.

Continuing the theme of digging deeper into topics I'm familiar with but not an expert in, today I want to focus on programming paradigms.

What are programming paradigms?

Programming languages can be designed to accommodate what "style" of programming you can do with them. This is not to say, what you can build with them, but more of how you build with them. A paradigm is an abstract way of thinking about writing code. This is what I understand about it at the moment. I will have to look up the definition and come back here.

Ok so I was not too far off, this is from Wikipedia:

Programming paradigms are a way to classify programming languages based on their features. Languages can be classified into multiple paradigms.

At this point, I ran into an interesting issue. Wikipedia mentioned "programming models" which is a term I haven't used before and haven't heard much before so I started looking into this.
Both programming models and programming paradigms almost step on each other's toes when being defined and I'm going to try my best to separate out the two. A programming model is a way to structure code and/or how a program's design is implemented at a high level. While a programming paradigm is a fundamental way of thinking about how a problem can be solved using a specific language.
I think I'll have more differentiation in the examples below

Examples of programming paradigms

Let's list some programming paradigms so it might make more sense.

Declarative programming

This paradigm focuses on what you expect to see as a result of writing some code, it is usually found in languages like SQL, HTML, and CSS. These examples are all languages that are not general purpose programming languages and are instead used for specific purposes. In the SQL example, you are telling the database to give something back based on a statement instead of computing or using a lot of logic. Logic is possible in declarative programming but it's more oriented towards rules or conditions instead of loops and computed checks.

Here's a CSS example of something completely declarative:

h1 {
  color: blue;
  font-size: 24px;
}

In this CSS example, we're not checking or referencing anything and in general just telling the rendering engine what the color and font size should be.

And a SQL example:

SELECT name, age FROM users WHERE age > 25;

In the SQL example, it's all declared to the database engine instead of anything being calculated or determined in the code.

I learned a lot about declarative programming from this Stack Overflow answer →.

Imperative programming

Naturally, the next paradigm that makes sense to look at is something that contrasts pretty hard against declarative. Instead of being declarative statements of what a program should do, imperative programming uses statements that change the program's state as it runs. It tells the program "how" something should be done.
Imperative programming is made up of procedures or functions which is also why it's sometimes called procedural programming.
There are a lot of programming languages that use imperative programming, like C, Python, Javascript, Java, and so many more.
Below are some examples of the same thing being accomplished with these two different paradigms:

Addition example using declarative programming

const numbers = [1, 2, 3, 4, 5];
const result = numbers.reduce((acc, current) => acc + current, 0);
console.log(result); // prints out: 15

Addition example using imperative programming

function sumArray(arr) {   
	let sum = 0;   
	for (let i = 0; i < arr.length; i++) {     
		sum += arr[i];   
	}   
	return sum; 
}  
const numbers = [1, 2, 3, 4, 5]; 
const result = sumArray(numbers); 
console.log(result); // prints out: 15

Both these examples accomplish the same thing but in the imperative example, we can reuse that sumArray function in multiple places, it's the "how" to do the addition, while in the declarative example, we simply do the math by using numbers.reduce() which makes code very clearly a one-time use.

What about object-oriented programming?
Object-oriented programming (OOP) takes imperative programming one step further by introducing the use of objects which can contain both data and code. The "code" in these objects is usually methods (functions within objects) which are more generally just procedures.
OOP also allows us to model real-world concepts as objects, like a 'person' object with properties such as name, age, and location, and methods to interact with the object. The person object would contain properties (data) like name, age, location and it would also have methods (procedures) which would allow you to add them as a friend, message them, or view a computed value like their full name in a sentence. OOP also introduces many other programming concepts like encapsulation, inheritance, and polymorphism which I'm not going to get into today.

Functional programming

This one is a subset of declarative programming. Functional programming is a loaded term, it can be a subset of declarative programming or it can be a purely functional programming which treats all functions as deterministic mathematical functions (aka pure functions). Functional programming emphasizes preventing side effects while running a program. This means if a function is written to simply do one thing and does not produce any side effects, there's potentially less room for errors or bugs. Haskell is a common example of a programming language that uses functional programming. Javascript can have functional code coexist with other types of code like imperative or declarative.

Addition example from before using functional programming

function add(a, b) {
  return a + b;
}

const result = add(3, 4);
console.log(result); // prints: 7

In this example, the add function will always return the same thing as long as the same input is given. The function also tries not to have any side effects like a console.log or some other unrelated operation.

Logic programming

This is brand new to me, I have been skimming through Wikipedia and ChatGPT to get a grasp of it. Logic programming is based on formal logic. It is declarative but unlike declarative programming where you state "what" you want, you can use it to build expert systems (decision making like humans) and natural language processing (NLP) and artificial intelligence. Rule based systems can also use logic programming to answer questions about a heuristic like fraud, trust, quality, etc.
Unlike other programming paradigms, in logic programming, you write statements and rules, and the computer determines the answer based on these rules.
The computer determines the answer based on the rules and statements you've provided to it.

I got the following example from ChatGPT so take it with a grain of salt.

% Define the criteria for a fraudulent user
fraudulent_user(User) :-
    has_many_accounts(User),
    has_unusual_activity(User),
    has_recent_suspicious_activity(User).

% Define predicates for various conditions
has_many_accounts(john).
has_unusual_activity(john).
has_recent_suspicious_activity(john).

% Sample user data
user(john, "John Doe", "johndoe@email.com").

% Query to check if a user is fraudulent
% Example: Is John a fraudulent user?
% Query: fraudulent_user(john).
% Expected Output: true (since John meets all the conditions).

In this example we're trying to determine if the user is fraudulent based on the various predicates. It's weird to me because it reads pretty much like a declarative language but I'm guessing this is because I'm looking at it from a decade plus of declarative and imperative programming experience.

Symbolic programming

The last one for today that I'm learning about is symbolic programming allows a program to manipulate its code as data. Lisp introduced symbolic programming. You can use symbolic programming to solve mathematical proofs and evaluate expressions on the fly. By the end of learning about symbolic programming, I didn't come away with a use-case for my own day to day programming but it's one of those things that will make sense over time.

Conclusion

Each of these programming paradigms really opened up old pathways in my brain that haven't been thought about for a long time now. Writing this up and then learning about new ones was a good use of time today.

Today's recommendation from ChatGPT was "Algorithms"–yup, just that, in one day, master all algorithms 🤣. But as reality set in, I wanted to narrow down to some algorithms I'm familiar with and try to see if I can dig into them past the high level understanding. I chose sorting algorithms specifically because it gives me a constraint. Searching algorithms could be a whole college course of their own so I'm not gonna get into those today.

Common sorting algorithms

At this point, I'm writing from the top of my head, all things I'm familiar with and then I'll go deeper into what things I don't understand or don't know about.

The few basic sorting algorithms are: selection sort, insertion sort, and bubble sort. Then there's slightly faster algorithms like merge sort.

Selection sort selects the smallest element and moves it to the beginning of the list. From my understanding, the big-O of insertion sort is always going to be N-1 because it has to check and compare.

Insertion sort picks an element and moves it if the next element is smaller, the picked element is moved until it's not smaller than the next element it's checking. But...this is kinda where my understanding of insertion sort stops. I should look into it more.

Bubble sort works similarly but it "bubbles" the elements in one way or another, for example in a list with [4,1,3,2,5], bubble sort will first bubble 4 all the way to the correct position, then go back to check from 1,2,3... this is super simple contrived example but it seems like that's the basic concept.

The above three algorithms use basic one check at a time approaches which can be ok for smaller sets of data but as the dataset grows in size, their runtimes can be very slow.

From what I've studied, the next algorithm I'm familiar with is merge sort. Merge sort uses a divide and conquer approach, and the trick up its sleeve is recursion. So it's good to have a grasp on how recursion works before diving into merge sort but simple put it takes the following steps:

1. splits the elements in half until each half only has 2 elements left
2. it sorts the elements
3. merges the sorted arrays

At a high level it seems simple but implementing it can be a bit tricky. First you have to handle the default case so the recursion knows when to end. This can be done by this: if array size is 1, return array. Next, you have to split the array into smaller arrays, so if an array is 5 elements big, you'd split one into 3 elements and the other into 2 elements. Now when it gets to the list with 2 elements, it will split them once more and at this point it will run a separate function that will "merge" these two. And the way it does this is by comparing which of the two single element arrays contains the smaller integer.

Here's a javascript implementation of this:

function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }

  const middle = Math.floor(arr.length / 2);
  const left = arr.slice(0, middle);
  const right = arr.slice(middle);

  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }

  return result.concat(left.slice(leftIndex), right.slice(rightIndex));
}

const unsortedArray = [64, 34, 25, 12, 22, 11, 90];
const sortedArray = mergeSort(unsortedArray);

console.log("Unsorted Array:", unsortedArray);
console.log("Sorted Array:", sortedArray);

Ok so these few I have a basic grasp of but I'm not too familiar with other sorting algorithms.

The following are new to me (from the wiki on sorting algorithms):

• Quicksort
• Heapsort
• Tree sort
• Library sort
• Block sort
• Tournament sort
• Timsort
• Patience sorting
  And a bunch more.

On Wikipedia, there's a nice comparison of different attributes for the algorithms like best, average, and worst runtimes along with memory usage, stability, and the method used for sorting.

For things like merge sort, the runtime the same in all cases which is O(n log n) but space usage is n (which isn't bad, IIUC). But things like Quicksort can be average n log n but worst can be n^2.

Quick sort

This one is a new one to me so I'm going to focus on it a bit because I want to learn about it.
So reading the algorithm details on wikipedia, this is what I found:

1. Because this is a recursive algorithm, when there less than 2 elements, then return.
2. If more than 2 elements, pick an element and call it the pivot.
3. Use two algorithms, one called quicksort and the other called partition, the former being the main function that will insure recursion stops when it needs to, splits the array at the pivot and passes one side of the partitioned array to one quicksort and the other to another quicksort function call.
4. Inside the partition function, the same approach is used as having a pivot and then using that to compare against.

Out of time

I spent way more than 2 hours on this today. I spent close to 3 hours on this and I wasn't able to capture all my thoughts and learnings into one succinct post. I'm happy with this because it forced me to go back and review my fundamental understanding of some basic algorithms.
I think in the future, I'd want to timebox better and stick with it.

Questions for future self

• How is quicksort better or worse compared to merge sort?
• What are some other useful and commonly used sorting algorithms?