Kelvin Wangonya

Handling missing dict keys, revisited

Wed, 08 Apr 2026 07:00:59 +0300

A while back, I wrote a post showing how to handle missing dict keys. In summary:

Using setdefault
Using defaultdict
Implementing __missing__

While the advice there still stands, I’ve been reading through Fluent Python and came across two things worth being aware of when subclassing dict:

__contains__ doesn’t call __missing__, so k in d returns False for keys not yet set, even if __missing__ would handle them
dict.get doesn’t call __missing__, so .get(k) won’t use your custom default

Both are by design and often what you want. __missing__ is only used by d[key], not other dict methods. Even defaultdict follows the same rule: only d[key] triggers the default factory and methods like .get() and in do not.

On Disabling Javascript

Fri, 24 Oct 2025 16:37:29 +0300

Update 2025-11-25: After trying this for about three weeks, I’ve found that disabling Javascript by default is really inconvenient. Many sites just don’t work properly without it, and having to manually enable it every time is a hassle. I guess that’s the tradeoff one would have to make in this case, but I probably just don’t care enough at the moment to go ahead with this. Of course I might revisit this again later, but for now it’s back to the default browsing experience.

Handling NULL values for "not equal" checks in SQL

Mon, 19 May 2025 11:08:03 +0300

This one bit me today. Apparently NULL values give unexpected results when checked using != or <>.

For example:

id | model | competitor_type
--------------------------------
1 | Ariya | NULL
2 | Frontier | NULL
3 | Rogue | Competitor
4 | Sentra | Non-competitor

SELECT * FROM table WHERE LOWER(competitor_type) != "non-competitor";

I expected to see ids 1, 2 and 3 as a result, but only got 3.

Be careful with join type typos

Thu, 07 Nov 2024 09:00:30 +0300

I noticed a typo in one of my sql queries today, but the funny thing is the query still worked fine. It looked something like this:

SELECT
 *
FROM
 table_1
LEFFT JOIN
 table_2
USING (a,b);

At first I thought BigQuery was pretty smart and just assumed I meant LEFT instead. Maybe it’s a common typo and there’s an alias for it. So I got curious and tried out this:

with statements don't create scope

Tue, 01 Oct 2024 16:27:39 +0300

I saw some code today that initialized a variable inside with and continued to use it outside the block. I’ve always assumed with statements had their own scope so this had me a little confused. Turns out this is perfectly fine.

A with statement does not create a scope (like if, for and while do not create a scope either).

As a result, Python will analyze the code and see that you made an assignment in the with statement, and thus that will make the variable local (to the real scope).

Spotify Cleaner

Wed, 25 Sep 2024 08:09:31 +0300

I’ve had my Spotify account for a long time, and over that time, my musical tastes have evolved. As a consequence, there are a lot of liked songs, playlists, and podcasts I no longer listen to but have in my library. There’s nothing wrong with keeping them in the library—I don’t have them downloaded, so they’re not really taking up any space—but I don’t like the clutter.

As far as I know, Spotify doesn’t provide any way to batch delete things, so I created a spotify-cleaner for this.

man pages have sections!

Wed, 25 Sep 2024 05:47:44 +0300

I noticed this when reading through Beej’s Guide to C Programming. While explaining printf, reference is made to man 3 printf - which looked different from how I usually run man. Why the 3?

So I ran man printf instead. Output:

Then man 3 printf:

Learning touch typing

Tue, 27 Aug 2024 06:22:21 +0300

I now understand why I’ve always had a hard time getting into Vim. I’ve tried it on and off for years, and of everything I’ve read about it, I have not seen ‘knowing to type properly’ as a prerequisite. I think it is. ‘Keeping your fingers on the home row’ is a big thing with it, but this doesn’t help if you’re not usually typing with your fingers on the home row in the first place.

On embracing asynchronous communication

Wed, 27 Mar 2024 12:12:34 +0300

I’ve been trying to improve my workflows this year. One thing I’ve known for a while, but never really got serious about implementing, is defaulting to asynchronous communication. I first learned about this concept a few years ago when reading Basecamp’s Employee Handbook.

I work remotely for a company in the UK, and we use Slack for communication. The timezone difference is only two/three hours, so the whole team is usually all online at the same time for most of the day. I (and I’m sure most other members of the team) just find it a lot easier to pull someone in for a ‘quick’ huddle each time there’s something to discuss. I always hesitate before doing this, but end up doing it anyway most of the time. The fact that it is very easy to do doesn’t help. I think it does more harm than good.

Pydantic validators don't raise validation errors immediately

Wed, 06 Mar 2024 05:15:40 +0300

This one really had me confused. I was facing an error with Pydantic validators which I thought I had handled, but it just didn’t work as expected.

The schema looked something like this:

class Schema(BaseModel):
 dates: List[str]
 start_date: Optional[str]
 end_date: Optional[str]
 ...

 @validator("dates")
 def update_date_format(cls, v):
 ...

 @validator("start_date")
 def set_start_date(cls, v, values):
 # some logic here that expects `dates` to exist
 v = values['dates'][0]
 return v

 @validator("end_date")
 def set_end_date(cls, v, values):
 # some logic here that expects `dates` to exist
 v = values['dates'][-1]
 return v

My assumption in the last two validators was that dates would always be available because it’s a required field. To my surprise, an IndexError was always raised on set_start_date.

Trying out Ubuntu 23.04

Thu, 07 Sep 2023 05:34:19 +0300

I haven’t used Ubuntu since I first discovered Linux 9 years ago in University, so I thought I’d give it a try this past weekend. I didn’t like it. I only used it for a day and a half before I had to wipe everything and go back to Manjaro.

Before I get into the things that really bothered me, here’s what I liked:

1. Online accounts

This is more of a Gnome thing than Ubuntu, but still, I love that I can add all my online accounts in the settings and have everything synced up automatically in the calendar and email apps. I love KDE Plasma, but this is the one thing I really miss in it.

Python slots

Tue, 15 Aug 2023 22:03:09 +0300

I just learned about this today while going through the python mastery course. Apparently, some good memory optimization can be done by using it in classes.

This answer does a good job explaining how it works.

I’ve not had a need for it yet, but it’s a good thing to keep in mind for when I do end up needing it.

Incron

Wed, 12 Jul 2023 08:58:30 +0300

incron is an “inotify cron” system. It consists of a daemon and a table manipulator. You can use it a similar way as the regular cron. The difference is that the inotify cron handles filesystem events rather than time periods.

I use it to auto-commit changes made to specific files to version control.

Example usage

View incrontabs:

Add/edit incrontabs:

Taking notes

Fri, 23 Jun 2023 18:26:44 +0300

I need to get in the habit of taking notes while I work. Especially when I’m debugging. I’ve noticed a poor habit recur when I’m working on a particularly difficult problem.

It usually goes something like this:

Start working on problem. Do some research. Try out A.
A doesn’t work. Do some more research. Try B.
B doesn’t work.
Try C. Nothing.
At this point I’m already tired so I think to myself, “A seems like a pretty good idea. Why didn’t it work? Let’s try it again.”.
Oh, that’s why A didn’t work. Of course.
Try some variation of B.
Try C again.
Think about A some more…

So much time is wasted, with very little progress made. Even worse, if this is at the end of the day and I have to leave it pending and come back to it the next day - or if I have to stash the changes and work on something else for a while then come back to it later, then the cycle begins all over again.

Adding anything to i3blocks

Wed, 14 Jun 2023 21:34:04 +0300

This was initially a post about adding what’s playing on Spotify to i3blocks. I had just started using i3blocks then and thought it was pretty cool how easy it was to do. I’ve since discovered the possibilities are endless. You can add pretty much anything that outputs text to the statusbar.

Below are some examples of what’s possible.

Showing and controlling music

I like seeing what’s playing without having to bring up the Spotify app every time. If I can also control playback without bringing up the app, even better.

mysql-dump specific tables

Sat, 13 Aug 2022 15:19:50 +0300

If you only need to dump one table:

mysqldump -u username -ppassword db_name table_name > dump.sql

For multiple tables, separate the table names with a whitespace:

mysqldump -u username -ppassword db_name table_name_1 table_name_2 > dump.sql

To only get tables with a certain prefix, e.g pref_:

mysqldump db_name $(mysql -D db_name -Bse "show tables like 'pref\_%'") > dump.sql
# flags: -B batch, -s silent mode, -e execute

To only dump rows that meet a specific criteria:

Grokking algorithms notes

Sat, 21 May 2022 12:03:23 +0300

Book: https://www.manning.com/books/grokking-algorithms

The Feynman algorithm

Write down the problem.
Think real hard.
Write down the solution.

Binary search

Use if the input is sorted.

If the input consists of numbers, for example, half the numbers are eliminated in each step with binary search. When searching for a number between 1 and 100, a maximum of 7 steps are needed to get the result.

In general, for any list of n, binary search will take log₂n steps to run in the worst case.

Checking string contains substring

Fri, 29 Apr 2022 11:02:01 +0300

From this answer:

import (
 "fmt"
 "regexp"
 "strings"
)

const (
 str = "something"
 substr = "some"
)

// 1. Contains
res := strings.Contains(str, substr)
fmt.Println(res) // true

// 2. Index: check the index of the first instance of substr in str, or -1 if substr is not present
i := strings.Index(str, substr)
fmt.Println(i) // 0

// 3. Split by substr and check len of the slice, or length is 1 if substr is not present
ss := strings.Split(str, substr)
fmt.Println(len(ss)) // 2

// 4. Check number of non-overlapping instances of substr in str
c := strings.Count(str, substr)
fmt.Println(c) // 1

// 5. RegExp
matched, _ := regexp.MatchString(substr, str)
fmt.Println(matched) // true

// 6. Compiled RegExp
re = regexp.MustCompile(substr)
res = re.MatchString(str)
fmt.Println(res) // true

Option two easily solves this problem.

Handling missing dict keys

Thu, 10 Feb 2022 06:10:15 +0300

Trying to access a non-existent key using this notation: dict[key] raises a KeyError. An easy workaround for this is to use get(key) instead, which returns None if key isn’t found, or get(key, default) which returns default if key isn’t found.

>>> d = {}
>>> d
{}
>>> d["x"]
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'x'
>>> d.get("x")
>>> d
{}
>>> d.get("x","y")
'y'
>>> d
{}
>>>

But what if you want to not only return a default if the key is missing, but also assign that default to the specified key in the dict? There are a couple of ways to do that.

Kadane's algorithm

Thu, 02 Dec 2021 08:25:49 +0300

Possible use case: Maximum subarray problem.

Steps

Initialize two variables: max_sum = current_sum = 0
Loop through numbers in list
- Set current_sum = max(0, current_sum + list[i])
- Set max_sum = max(max_sum, current_sum)
Return max_sum

Caveats ¹, ²

Kadane’s Algorithm requires at least one positive number, so an input of all negative numbers would be invalid.
If the array contains all non-negative numbers, then the problem is trivial; a maximum subarray is the entire array.
If the array contains all non-positive numbers, then a solution is any subarray of size 1 containing the maximal value of the array (or the empty subarray (which has sum 0), if it is permitted).
Several different sub-arrays may have the same maximum sum.

Solving Best Time to Buy and Sell Stock with Kadane’s Algorithm

Slightly tweak the algorithm to track max profit and min price.

Running multiple programs in parallel from a bash script

Mon, 22 Nov 2021 06:58:33 +0300

This comes in handy when I want to, for example:

run a MySQL proxy to Cloudql or similar, then
run a project server (fastapi, django etc) that depends on the database connection

From this answer:

set -m # enable job control

prog1 & prog2 && fg

This will:

Start prog1.
Send it to background, but keep printing its output.
Start prog2, and keep it in foreground, so you can close it with ctrl-c.
When you close prog2, you’ll return to prog1’s foreground, so you can also close it with ctrl-c.

Processing iterators in parallel

Wed, 03 Nov 2021 06:13:46 +0300

Use zip

zip(*iterables, strict=False)

Iterate over several iterables in parallel, producing tuples with an item from each one.

Examples

Without zip

countries = ["Kenya", "Tanzania", "Uganda"]
capitals = ["Nairobi", "Dodoma", "Kampala"]

print("=== using range ===")
for i in range(len(countries)):
 country, capital = countries[i], capitals[i]
 print(f"Country: {country}, Capital: {capital}")

print("=== using enumerate ===")
for i, country in enumerate(countries):
 country, capital = countries[i], capitals[i]
 print(f"Country: {country}, Capital: {capital}")

Output:

=== using range ===
Country: Kenya, Capital: Nairobi
Country: Tanzania, Capital: Dodoma
Country: Uganda, Capital: Kampala

=== using enumerate ===
Country: Kenya, Capital: Nairobi
Country: Tanzania, Capital: Dodoma
Country: Uganda, Capital: Kampala

With zip

print("=== using zip ===")
for country, capital in zip(countries, capitals):
 print(f"Country: {country}, Capital: {capital}")

Output:

Getting the Python version at runtime

Sun, 24 Oct 2021 17:42:19 +0300

import sys

print(sys.version)

Output:

3.9.7 (default, Aug 31 2021, 13:28:12)
[GCC 11.1.0]

You can use your database as a simple calculator

Sat, 23 Oct 2021 17:49:32 +0300

Saw this in the MySQL docs. I’m assuming this only works for relational databases.

I don’t know if it’s very useful but definitely interesting.

MariaDB[] > SELECT SIN(PI()/4), (4+1)*5;
+------------------+---------+
| SIN(PI()/4) | (4+1)*5 |
+------------------+---------+
| 0.70710678118655 | 25 |
+------------------+---------+
1 row in set (0.02 sec)

postgres=# SELECT SIN(PI()/4), (4+1)*5;
 sin | ?column?
--------------------+----------
 0.7071067811865475 | 25
(1 row)

Setting up PostgreSQL on Arch Linux

Fri, 15 Oct 2021 16:09:08 +0300

Arch Linux PostgreSQL docs

Install

$ sudo pacman -S postgresql

Setup the data directory

$ sudo -iu postgres
[postgres]$ initdb -D /var/lib/postgres/data

Start postgresql.service

$ systemctl start postgresql.service
$ systemctl enable postgresql.service

Add user

[postgres]$ createuser --interactive

Create db

$ createdb myDatabaseName

Setting up MariaDB on Arch Linux

Fri, 15 Oct 2021 15:56:36 +0300

Arch Linux MariaDB docs

MariaDB is a reliable, high performance and full-featured database server which aims to be an ‘always Free, backward compatible, drop-in’ replacement of MySQL. Since 2013 MariaDB is Arch Linux’s default implementation of MySQL.

Install

$ sudo pacman -S mariadb

Setup the data directory

$ sudo mariadb-install-db --user=mysql --basedir=/usr --datadir=/var/lib/mysql

Start mariadb.service

$ systemctl start mariadb.service
$ systemctl enable mariadb.service

Add user

In the below example, the user monty with some_pass as password is being created, then granted full permissions to the database mydb:

Getting the running Go version

Sat, 24 Jul 2021 05:02:01 +0300

package main

import (
 "log"
 "runtime"
)

func main() {
 log.Printf("Running Go: %s", runtime.Version())
}

Output: Running Go: go1.16.6

Writing DRYer tests using pytest parametrize

Thu, 08 Apr 2021 17:08:41 +0300

Tests don’t always need to be DRY, which isn’t necessarily a bad thing.

This SO answer sums it up nicely:

Readability is more important for tests. If a test fails, you want the problem to be obvious. The developer shouldn’t have to wade through a lot of heavily factored test code to determine exactly what failed. You don’t want your test code to become so complex that you need to write unit-test-tests.

What happens when you run PSQL slash commands?

Thu, 10 Dec 2020 05:51:19 +0300

Running \? within a psql database gives a whole list of commands that come in handy when performing various kinds of tasks.

$ psql
psql (13.0)
Type "help" for help.

wangonya=# \?
General
 \copyright show PostgreSQL usage and distribution terms
 \crosstabview [COLUMNS] execute query and display results in crosstab
 \errverbose show most recent error message at maximum verbosity

 .....

But what are the queries executed when these commands run?

I was recently tasked to write a bash script that loops through every schema on a database and does a pg_dump on it for backup then uploads the backups to an external server.

Working with celery signals

Tue, 03 Nov 2020 06:17:15 +0300

If you’re new to celery, start here.

Sometimes when using celery, you may want to get notified when a task running in the background executes successfully or when it fails. You may also want to run a function each time before the celery task runs or after it completes. These and many others along the same line are all situations where signals would come in handy.

I’ll create a simple file tasks.py and set up celery to demonstrate how to use celery signals.

Shallow & deep copying in Python

Sun, 21 Jun 2020 12:36:17 +0300

What happens when a variable is assigned to another variable in python? For example:

>>> x = 5
>>> y = x

Both x and y will have the value 5. But, when x was assigned to y, y was not created as a completely new/separate object. Instead, an alias for x was created. That is, y points to the memory location of x. It does not have its own memory location - yet.

>>> id(x)
140428600776960
>>> id(y)
140428600776960
>>> x is y
True

You may never have any problems with this when working with immutable types because the alias is broken as soon as either of the two variables change.

Variables & mutability in Rust

Sun, 14 Jun 2020 22:33:13 +0300

By default, variables are immutable in Rust. Coming from a Python background, I have to keep in mind that this:

fn main() {
 let var = 10;
 println!("var = {}", var); // var = 10
 var = 5; // try and reassign var
 println!("var is now {}", var);
}

… will not compile.

The rust compiler gives a clear output of what went wrong:

error[E0384]: cannot assign twice to immutable variable `var`
 |
2 | let var = 10;
 | ---
 | |
 | first assignment to `var`
 | help: make this binding mutable: `mut var`
3 | println!("var = {}", var); // var = 10
4 | var = 5; // try and reassign var
 | ^^^^^^^ cannot assign twice to immutable variable

Once a value is assigned to var, var is bound to that value until it goes out of scope.

When to use Python's enumerate() instead of range() in loops

Sun, 26 Jan 2020 00:00:00 +0000

The range() function is often useful when iterating over a set of integers:

for n in range(50):
 ...

#

for n in range(10, 30):
 ...

or a list of strings:

for fruit in ["apple", "mango", "banana"]:
 ...

Now, say you want to iterate over the list of fruits and also show the index of the current item in the list. Using range(), this might be done like this:

fruits = ["apple", "mango", "banana"]

for i in range(len(fruits)):
 fruit = fruits[i]
 print(f"{i}: {fruit}")

# Output:
# 0: apple
# 1: mango
# 2: banana

It gets the job done, but not very pythonic. You have to get the length of the list to keep track of the index, then index into the array to get the current fruit - which makes the code more verbose and harder to read.

difflib - finding close matches of strings from a list

Sun, 22 Sep 2019 00:00:00 +0000

Say we have a list of strings: _list = [...,] and user input _input = '...', how do we find the items in _list that most closely resemble _input?

Python has a built-in package called difflib with the function get_close_matches() that can help us.

get_close_matches(word, possibilities, n, cutoff) accepts four parameters:

word - the word to find close matches for in our list
possibilities - the list in which to search for close matches of word
n (optional) - the maximum number of close matches to return. Must be > 0. Default is 3.
cutoff (optional) - a float in the range [0, 1] that a possibility must score in order to be considered similar to word. 0 is very lenient, 1 is very strict. Default is 0.6.

An example from the docs:

HTML to JSX compiler

Mon, 09 Sep 2019 00:00:00 +0000

I just came across this online HTML to JSX Compiler. If you’re new (or not) to react and you’re still having a little trouble with JSX, I think this tool is great for learning.

Just paste in your HTML in the HTML editor on the left, and it’ll be converted into valid JSX on the right.

Python 'is' vs '=='

Fri, 06 Sep 2019 00:00:00 +0000

A lot of times when I’m using if in Python, I find myself wondering whether to use is or == for the check.

# do I do
if a is b:
 ...

# or
if a == b:
 ...

It can be a bit confusing if you’re new to Python, and it’s easy to assume the two can be used interchangeably. So, what’s the difference?

`is`

The is operator checks if both elements point to the same object. Let’s fire up a python console to help illustrate this:

Making your SMART goals smarter with stretch goals

Fri, 30 Aug 2019 00:00:00 +0000

I’ve been reading the book "Smarter Faster Better" by Charles Duhigg and in it, he gives a perspective on goal-setting that I found interesting.

You may already know about SMART goals, which is an awesome format to set your goals in. It does have a subtle pitfall though: cognitive closure.

Cognitive closure

Cognitive closure (psychology), the human desire to eliminate ambiguity and arrive at definite conclusions (sometimes irrationally) - Wikipedia

You know that nice feeling of crossing things off your to-do list? Closure. Which is great, for the most part. It only gets bad when we end up expending more effort to get immediate results, when we are so focused on small daily "wins" that we lose focus on the larger picture.

Automatically counting and numbering HTML elements with CSS counters

Sat, 24 Aug 2019 00:00:00 +0000

Say you had an unknown number of <div> elements and (for some reason) you wanted to count them and number each of them automatically - how would you do it? If you’re like me, your first thought would be to use some kind of Javascript to play around with the DOM. What if I told you (insert Morpheus voice here) you can do it with CSS?

How to use CSS counters

Getting counters working requires three steps:

Publishing your Python packages on TestPyPi before publishing on PyPi

Fri, 23 Aug 2019 00:00:00 +0000

If you’re just creating a package for learning purposes, there’s no need (IMO) to pollute the official PyPi index with it. Also, you may want to release a package to a select number of users for testing before you actually release it officially. For these purposes, you’re better off using TestPyPi:

a separate instance of the Python Package Index that allows you to try distribution tools and processes without affecting the real index.

Testing Click applications with pytest

Tue, 20 Aug 2019 00:00:00 +0000

It’s good practice to, as much as possible, write tests for your code. If you’re working with Python, pytest makes the process of writing and running tests much smoother. I wrote a few posts some time back on getting started with testing with pytest, so if you’re completely new to it, you might want to take a look at them:

For testing CLI apps, Click provides a convenient module: click.testing which has some useful functions (notably CliRunner()) to help us invoke commands and check their behavior.

Performing CRUD operations with a CLI app using Firebase

Thu, 15 Aug 2019 00:00:00 +0000

For the next phase in this series, we’ll learn how to make a CLI app to perform CRUD operations, i.e., Creating, Retrieving, Updating and Deleting data. We’ll use Firebase to store our data.

What we’ll create

A contacts app with the following functionality:

# add a new contact with name=Peter and mobile=01034512
$ contacts add Peter --mobile 01034512
Contact Peter added!
{ 'mobile': '01034512' }

# view all contacts
$ contacts list
Here's a list of all your contacts:
{ ... # list of all contacts }

# view single contact
$ contacts view Peter
{ 'mobile': '01034512' }

$ contacts view Meg
The contact you searched for doesn't exist

# update mobile number for Peter
$ contacts update Peter --mobile 00000
Contact updated!
{ 'mobile': '00000' }

# delete the contact Peter
$ contacts delete Peter
Contact deleted!

This post is a bit long. If you just want to take a look at the code or see how the app works, check out the repo.

Prompting users for input

Sat, 10 Aug 2019 00:00:00 +0000

Getting user input is an important part of any kind of application. Since we’ve already learned about options, adding a user prompt to our hello world app should be a breeze. All we need to do is add prompt=True to the option decorator, so that it prompts the user for input if no option is passed in.

# helloworld.py

import click

@click.command()
@click.option('-c', '--case',
 type=click.Choice(['upper', 'lower']),
 prompt=True)
@click.argument('person', default='you')
def hello(case, person):
 response = "Hello World! Also, hey {} ☺️".format(person)
 if case == 'upper':
 click.echo(response.upper())
 elif case == 'lower':
 click.echo(response.lower())
 else:
 click.echo(response)

Save and run the app:

Adding arguments to CLI commands

Fri, 09 Aug 2019 00:00:00 +0000

Arguments work very similarly to options. If you’re familiar with functional programming, then you’re familiar with arguments. The concept is the same in Click.

Let’s edit our code a bit to see how we can integrate arguments.

# helloworld.py

import click

@click.command()
@click.option('-c', '--case', type=click.Choice(['upper', 'lower']))
@click.argument('person', default='you')
def hello(case, person):
 response = "Hello World! Also, hey {} ☺️".format(person)
 if case == 'upper':
 click.echo(response.upper())
 elif case == 'lower':
 click.echo(response.lower())
 else:
 click.echo(response)

Just like with commands and options, Click provides a decorator to add arguments.

Adding options to CLI commands

Wed, 07 Aug 2019 00:00:00 +0000

In the previous post, we used setuptools to package our app and enable us to run it using a single executable command hello. In this post, we look at how to make CLI apps more functional and interactive using options.

Options

Options are used to alter the default behavior of commands. This is often accomplished by passing in parameters in the form of --option or -o for short.

Let’s assume that instead of just printing out "Hello World!", we wanted to have the option of printing it in all lowercase characters or all uppercase characters. We can add this functionality by adding an option() decorator.

Using setuptools to package your Python app

Mon, 05 Aug 2019 00:00:00 +0000

In our previous post, we made a Hello World! app to get us started with Click. You might have noticed though that we needed to do python hello-world.py to run it. Since we’re building CLI apps, that’s just not cool and it’s not how CLI apps work anyway. We need to be able to run a single command, something like:

(venv) $ hello
Hello World!

That’s where setuptools comes in. Setuptools helps us bundle our script so we can install it and run it like an app ($ hello), instead of like a script ($ python hello-world.py).

Setting up your Python environment for Click

Fri, 02 Aug 2019 00:00:00 +0000

In this post, we’ll cover the very basics of working with Python and Click to create a CLI app. We’ll install Python 3, set up our development environment, install Click, and create a hello-world app.

Python 3.x

Getting started with Python is easy. Most *nix systems come with Python pre-installed. We’ll be using Python 3. To check which version of Python you have, open up your terminal and run python -V. You should get an output similar to this:

Fibonacci sequence with Python recursion and memoization

Sun, 16 Jun 2019 00:00:00 +0000

The Fibonacci sequence is a sequence of numbers such that any number, except for the first and second, is the sum of the previous two.

For example:

[0, 1, 1, 2, 3, 5, 8, 13, 21...]

We can represent this in the formula:

fib(n) = fib(n-1)+fib(n-2)

With this formula, we can write a simple recursive function to solve for fib(n).

Note: Only use this to test for small numbers, preferably n < 10. I’ll explain later

Creating a simple ToDo API with Django

Mon, 01 Apr 2019 07:57:54 +0300

In this tutorial, we’ll create a simple todo api with Python 3 and Django 2.

Installing the requirements

Create a virtual environment and install Django.

$ virtualenv venv # creates a virtual environment
$ source venv/bin/activate # activates the virtual environment
(venv)$ pip install Django

That’s all we’ll need for now.

Creating the project

Use the Django startproject command to create the project we’ll be working on.

$ django-admin startproject todoapi

This creates a todoapi directory with generated files to start us off. The directory should look something like this:

Staying alert without caffeine

Sun, 17 Mar 2019 18:02:01 +0300

After my first post on "Caring for your Health as a Developer", I decided to do a bit of research on caffeine, specifically in coffee. I did learn quite a bit but what I found most interesting was that after oil, coffee is the 2nd most traded commodity in the world 🤯. People are really drinking a lot of coffee (2.25 billion cups of coffee on a daily basis). But while many may love and enjoy the momentary energy boost provided by caffeinated drinks, is it really the best way to go in the long term?

Caring for your health as a developer

Thu, 14 Mar 2019 19:54:39 +0300

"When health is absent, wisdom cannot reveal itself, art cannot manifest, strength cannot fight, wealth becomes useless, and intelligence cannot be applied." ― Herophilus

Let’s face it. As developers, it’s easy to let things get a bit out of hand when it comes to health. Many times we find ourselves in front of screens for hours on end. We sleep really late (or not at all) sometimes. Unless you’re disciplined enough to follow a schedule, you might find yourself not having time to eat proper meals so snacking becomes a habit. All these are usually sacrifices made to fix some bug or find the most efficient solution to some problem. Usually, our health suffers as a result. While this might seem to work out just fine for the moment, we don’t look at the bigger picture - how it will affect us in the future.

Lexical variable scoping with Javascript

Fri, 08 Mar 2019 12:52:10 +0300

Lexical scoping means that the scope of a variable is determined by where it is defined in the source code — specifically, by the block or function it is written inside. In Javascript, code blocks are created using curly braces ({}). For example:

function someFunction() {
 // some code here
}

function anotherFunction() {
 // some more code here
}

someFunction and anotherFunction are two different code blocks. These two different code blocks could also be considered as two different scopes. What that means is that the variables declared in someFunction only affect that block of code, and those declared in anotherFunction only affect that block of code. They are "scoped" in that sense.

Javascript arithmetic cheat sheet

Tue, 05 Mar 2019 05:25:12 +0300

Given that one of the main reasons computers were invented was to solve mathematical problems quickly, it is no wonder that all the modern programming languages are so rich in arithmetic-oriented methods. The earliest computers were basically just calculators. (Yes, I’m looking at you Abacus). If you dabble in Javascript (and a little math every now and then), you might find this useful. The very obvious operations like simple addition (+) and subtraction (-) have been omitted. So have more advanced operations.

Difference between a Python module and a package

Wed, 20 Feb 2019 18:35:12 +0300

Modules

Modules are single Python files that can be imported. Any python file can be a module. For example, if I have two Python files: module.py and hello.py in the same directory:

# module.py

def hello(name):
 print("Hello {}".format(name))

I can import that module in my hello.py:

#hello.py

import module

module.hello("World!") # Hello World!

The same can be done in the interpreter:

>>> from module import hello
>>> hello("World!") # Hello World!

Packages

Packages are made up of multiple Python files (or modules), and can even include libraries written in different languages like C or C++. Seeing an __init__.py file in a folder typically tells you that that folder is a Python package. The __init__.py doesn’t have to contain any code – sometimes it does – it just has to be there for Python take that particular folder as a package.

Displaying a css spinner on ajax calls with fetch api

Fri, 01 Feb 2019 08:18:26 +0300

I always have to search for how to do this or refer back to my previous code whenever I work with fetch. For a while, I’ve used the solution to this SO question. It’s a correct solution and it works great but to be honest, I couldn’t clearly explain that piece of code if asked. So I thought of a simple way to do it. Here’s how:

Setting up the HTML

<!-- this will fetch the data -->
<button onclick="loadData()">Load data</button>

<!-- this will show our spinner -->
<div hidden id="spinner"></div>

The spinner visibility is hidden by default using the built-in hidden attribute. This is the element we’ll manipulate in order to show and hide it as desired.

Skipping tests

Thu, 31 Jan 2019 08:16:36 +0300

Sometimes you might want to skip a particular test while executing others for some reason. Maybe the database guy isn’t done setting up and that particular test requires a database connection. Instead of having to wait, you can just write the test and instruct pytest to skip it. Give the appropriate reason so it doesn’t look like you just skipped a failing test to keep your test suite green.

There are a couple of ways to do this.

Capturing print statements while debugging

Wed, 30 Jan 2019 08:06:29 +0300

You might need to capture print statements in your tests while debugging. This might be just to help you debug, or for some other reason. I mostly do this kind of thing when testing for database connections where, in addition to other tests, I want to make sure I see that "Database connection successful" message.

Let’s demonstrate with a simple example:

def add_numbers(num1, num2):
 print("Add function started...")
 result = num1 + num2
 print("Numbers added. Returning result...")
 return result

def test_add_numbers():
 assert add_numbers(2, 3) == 3

Running the test above fails with the given traceback:

Asserting exceptions with pytest

Tue, 29 Jan 2019 05:15:40 +0300

The first time I had someone review my pull requests, she was pretty strict on tests. I couldn’t merge if the tests were failing, of course. But I also couldn’t merge if coverage had decreased. TDD was still new to me so maintaining coverage was a challenge since I was only testing the bare minimum I could. I had to find out how to make my tests more robust and ensure as much of my code was tested as possible. One area that I wasn’t really sure how to test was the custom exceptions I had written.

Getting started with pytest

Mon, 28 Jan 2019 08:15:40 +0300

Test-Driven Development is great. If you’re a Pythonista, it gets even better with pytest - a framework that makes building simple and scalable tests easy.

In this series, I’ll be exploring the cool features that pytest offers to help make testing Python code a breeze.

Preparing your python environment

Let’s set up our testing environment with virtualenv. We’ll be working with Python 3. cd into your working directory and create a new virtual environment:

Python's heapq module

Fri, 21 Dec 2018 00:00:00 +0000

Often when working with collections of data, you may want to find the smallest or largest item. It’s easy enough to write a function that iterates through the items and returns the smallest or largest one, or use the builtin min(), max(), or sorted() functions. Another interesting way may be implementing a heap (priority) queue.

Python provides a pretty convenient module called heapq that does that for you. heapq comes with a cool set of inbuilt functions that you can read more about in the docs.

Sorting algorithms with Javascript (Part 2)

Sun, 04 Nov 2018 00:00:00 +0000

I’m going to show Javascript implementations of three more sorting algorithms:

Quick sort
Heap sort
Counting sort

Again, this is not intended to be an in-depth explanation on the ins and outs of how the algorithms work and their performance. If you’d rather read about that, here’s a nice resource I found: Sorting Algorithms

To keep things simple, I’ll be sorting a simple list list having only 5 elements [4, 2, 3, 1, 5].

Sorting algorithms with Javascript (Part 1)

Thu, 18 Oct 2018 00:00:00 +0000

I’ve been learning a lot about data structures and algorithms lately and I’ve noticed in my reading that there aren’t a lot of examples showing implementations of algorithms in Javascript. You’ll mostly find examples in Java, Python, C, C++ etc. Maybe there’s a reason for preferring these languages over Javascript? I’m not sure.

In this first part, I’m going to show Javascript implementations of three sorting algorithms:

Merge sort
Insertion sort
Bubble sort

This is not intended to be an in-depth explanation on the ins and outs of how the algorithms work and their performance. If you’d rather read about that, here’s a nice resource I found: Sorting Algorithms

Javascript lookaheads and lookbehinds

Wed, 29 Aug 2018 00:00:00 +0000

Regular expressions are patterns used to match character combinations in strings. They help us work with strings in a very performant way.

By formulating regex with a special syntax, you can:

search text in a string
replace substrings in a string
extract information from a string

If all this is completely new to you, take a look at the mdn web docs for more info.

For this post, I’ll focus on one of the easier (and very useful) ways you can use regex.

Javascript array iteration with some() and every()

Tue, 28 Aug 2018 00:00:00 +0000

If you’re using an array in your code, chances are, you’ll need to iterate over the values in the array. There’s a couple of ways you can do that, some better and more efficient than others depending on what you want to accomplish.

For this post, I’ll focus on two ways: some() and every().

`some()`

The some() method tests whether at least one element in the array passes the test implemented by the provided function. It checks the elements one by one, and if it finds an array element where the function returns a truthy value, some() returns true and does not check the remaining values. Otherwise, it returns false.

'this' and arrow functions

Mon, 27 Aug 2018 00:00:00 +0000

Arrow functions were introduced in ES6 as a new syntax for writing Javascript functions. Thanks to their short syntax, they encourage the use of small functions, which make code look cleaner (and () => just looks cooler 😄).

As a beginner just getting to wrap my head around ES6 syntax, I began using arrow functions everywhere without really understanding how they worked. As you might expect, I ended up running into some problems, especially with the this keyword.

Finding an element in the array (the ES5, ES6 and ES7 way)

Sun, 26 Aug 2018 00:00:00 +0000

This’ll be a quick one.

Say you want to check if a specific element exists in an array. There’s a couple of ways to do that:

ES5

`indexOf()`

indexOf returns the index of the first matching item found, or -1 if not found.

// check if a Fortnite ninja exists in the array
const ninjas = ["Alchemist", "Brawler", "Skirmisher", "Harvester"];

console.log(ninjas.indexOf("Brawler")); // 1
console.log(ninjas.indexOf("Harvester")); // 3
console.log(ninjas.indexOf("Assassin")); // -1 (doesn't exist)

`lastIndexOf()`

lastIndexOf() returns the index of the last matching item found, or -1 if not found.

Kelvin Wangonya

Handling missing dict keys, revisited

On Disabling Javascript

Handling NULL values for "not equal" checks in SQL

Be careful with join type typos

with statements don't create scope

Spotify Cleaner

man pages have sections!

Learning touch typing

On embracing asynchronous communication

Pydantic validators don't raise validation errors immediately

Trying out Ubuntu 23.04

1. Online accounts

Python __slots__

Incron

Example usage

Taking notes

Adding anything to i3blocks

Showing and controlling music

mysql-dump specific tables

Grokking algorithms notes

The Feynman algorithm

Binary search

Checking string contains substring

Handling missing dict keys

Kadane's algorithm

Steps

Caveats 1, 2

Solving Best Time to Buy and Sell Stock with Kadane’s Algorithm

Running multiple programs in parallel from a bash script

Processing iterators in parallel

Examples

Without zip

With zip

Getting the Python version at runtime

You can use your database as a simple calculator

Setting up PostgreSQL on Arch Linux

Install

Setup the data directory

Start postgresql.service

Add user

Create db

Setting up MariaDB on Arch Linux

Install

Setup the data directory

Start mariadb.service

Add user

Getting the running Go version

Writing DRYer tests using pytest parametrize

What happens when you run PSQL slash commands?

Working with celery signals

Shallow & deep copying in Python

Variables & mutability in Rust

When to use Python's enumerate() instead of range() in loops

difflib - finding close matches of strings from a list

HTML to JSX compiler

Python 'is' vs '=='

is

Making your SMART goals smarter with stretch goals

Cognitive closure

Automatically counting and numbering HTML elements with CSS counters

How to use CSS counters

Publishing your Python packages on TestPyPi before publishing on PyPi

Testing Click applications with pytest

Performing CRUD operations with a CLI app using Firebase

What we’ll create

Prompting users for input

Adding arguments to CLI commands

Adding options to CLI commands

Options

Using setuptools to package your Python app

Setting up your Python environment for Click

Python 3.x

Fibonacci sequence with Python recursion and memoization

Creating a simple ToDo API with Django

Installing the requirements

Creating the project

Staying alert without caffeine

Caring for your health as a developer

Lexical variable scoping with Javascript

Python slots

Caveats ¹, ²

`is`

`some()`

`indexOf()`

`lastIndexOf()`