DEV Community: Eric Mesa

Programming Update: March 2023

Eric Mesa — Sun, 16 Apr 2023 20:08:17 +0000

In March I continued to work on my programming projects as well as a little more Advent of Code.

Things started off with me finishing up my dreamhostapi and Dreamhost_DNS_Go projects in Golang. I got the API working under all the conditions that I need and I worked on both the output of the program and the logging. It now functions quite well for me to keep my dynamic DNS URLs up to date. My next step is something I’m going to do in a few of my cron scripts – have a separate JSON log that could be interpreted so that I could either have a daily email to let me know that the scripts all ran correctly or so that I can load them into Prometheus/Grafana to see on a dashboard how all my scripts are doing.

As I was doing my Let’s Plays to raise money for Extra Life, I noticed some quality of life updates I wanted to make for the output. I added a new output to contain the latest milestone reached, stopped message-containing output from saying “None” if there wasn’t a message, and I added a space in the output when no donations have been made so that it would appear prettier if being scrolled.

Finally, for Advent of Code, I decided that I would try and do all years at once so that I could get all the stars for the easy days. This led to me attempting some of the easier days in Go and Ruby.

How Go Helped Save Healthcare.gov!

Eric Mesa — Sat, 11 Mar 2023 01:56:52 +0000

I recently used Mastodon to ask for recommendations for Go podcasts and one of the suggestions was Go Time. One of the recent episodes in the feed was a rerun of an older episode about “How Go helped saved HealthCare.Gov“. This was extra interesting to me since I wrote my Master’s Special Project on Healthcare.gov. (I haven’t read it in nearly a decade, so I don’t know if it’s cringe-worthy at this point). The episode had on one of the programmers who helped get things back on track for the site. It was incredibly informative about the problems that led to the site not being responsive enough and how they were able to help fix it without scrapping the entire site. No matter what side of the political spectrum you’re on or if you’re even an American, the episode is fascinating for understanding how things can go wrong even when everyone has the best intentions and how to fix a large, complex code base.

header image from go.dev/blog post about the macot.

Programming Update: Jan 2023 and Feb 2023

Eric Mesa — Fri, 03 Mar 2023 12:19:00 +0000

January

January was a relatively light programming month for me. I was focused on finishing up end of year blog posts and other tasks. Since Lastfmeoystats is used to generate the stats I need for my end of year music post, I worked on it a little to make some fixes. The biggest fix was to change the chart titles not to be hardcoded. I didn’t realize it until I was reviewing my blog post, but I had hard-coded the year when I first wrote the code a couple years ago. I also changed the limits on some of the data I was collecting so that I could do more expansive trending for my overall stats.

February

February unexpectedly picked up with programming. Even more surprisingly, I didn’t start off working on the project I thought I would – a refactor of my Extra Life Donation Tracker. Instead I ended up first working on my Civilization VI Play By Cloud webhook project. I realized I didn’t have an easy way to add in new users, so I added an “add user” endpoint. It wasn’t too hard, but did require taking a hard look at some of the assumptions I’d made in the software.

The BIGGEST surprise for me was resuming work on my Go (golang) version of my Dreamhost DNS program and actually getting to a working solution in just a couple of hours; and so was born my first ever useful Go program. Back in September of last year I had tried to write this Go port of my program. The rationale was simple and two-pronged: First, I’d learned Go while doing Advent of Code and wanted to use a real program to exercise what I’d learned. Second, every time I upgrade the version of Python on my computer, the virtual environment would become invalidated and I wouldn’t realize my cronjob-based scripts weren’t working. So I wanted to take advantage of the fact that Go is a compiled language and wouldn’t need any virtual environments to run. I had been having issues understanding Go’s use of Structs to “unmarshall” (as they call it) JSON. (Definitely a place where Python is so DEAD SIMPLE!) For some reason it just clicked for me one weekend in February and I was able to create a working version. After posting to the /r/golang subreddit, I got some tips on how to make it more idiomatic Go and I spent the next couple weeks improving the code to take those tips into account.

Finally, in Feb I worked on my Snap-in-Time project. I started doing more frequent pushes to the remote backup and so those folders started getting too full of backups so I implemented the weekly culling on the remote server as well.

2022 In Programming

Eric Mesa — Fri, 17 Feb 2023 01:30:55 +0000

I started off the year mostly working on Python projects. For January and February I finally started making some great progress with understanding modern web frameworks and use of CSS frameworks rather than rolling my own. This not only helped with the Prophecy Practicum project, but would form the backbone to a lot of coding this year. I also wrote a utility to tally up my videos for my end of year video game roundup, saving me literal hours of time. As you can read from following the link above, I also worked on my long-running Extra Life Donation Tracker code.

I then took a break from coding during the months of March and April. I was running lots of races at the time and training for the Brooklyn Half-Marathon as well as focusing on my other hobbies.

In May, June, and July I came back to programming with a vengeance. It was pretty heavy in Circuit Python work as I did some quality of life improvements to my Adafruit MagTag weather project, fixed some connection disruptions with my Adafruit FunHouse, and restarted work on my Smoker Thermostat. I also added a web UI to my Civ VI Webhook program, added a UI for logging with my Extra Life Donation Tracker, added remote culling in my btrfs snapshot program, and fixed my Dreamhost DNS program to make it more robust.

In August I found out that I needed to modify my Amortization program because of changes to numpy. I also made the CLI output prettier thanks to using rich. I did some work on my Extra Life Donation Tracker again and tried to work on a fork of ClanGen (which ultimately led nowhere). But my biggest changes were once again with the Civ VI Webhook. I migrated from using JSON files to using MongoDB. This led to some greater efficiencies as well as allowing me to more easily jump between servers for better uptime. I also learned how to use HTMX which allows you to get some interactivity to your sites without having to learn Javascript.

In September I tried to rewrite my Dreamhost DNS program in Go and failed due to the way Go does JSON parsing. In October I mostly focused on a bunch of Quality of Life improvements to the Prophecy Practicum project. But I did also do some work on Advent of Code. Novemberwas light on programming, but I did make a script to post my top last.fm weekly listens to Mastodon. Finally, December was all Advent of Code.

Looking back over the year, it was mostly a year of refinements to long-running projects. I’ve got a suite of tools that I use pretty consistently or are used by others and this was a great year to add some spit and polish to those projects. I also learned a lot more than I thought I ever would about how modern web design works. I’m very curious to see what I work on in 2023.

Programming Update: December 2022

Eric Mesa — Fri, 13 Jan 2023 00:18:29 +0000

December was wholly dedicated to solving the Advent of Code 2022 problem set. Our job was to help the elves trek through the jungle to get magical starfruit. It was a lot of fun to do it live once again! This year I also had experience from the previous years (both live and on my own pace) that gave me the skills to solve some of the puzzles, including some puzzles that were variations on themes I’d seen before. In the end, I collected 36 stars, near my average for number of stars collected during AoC. Between work, family commitments, my programming and problem solving skill levels, that’s about the most I can usually do during the live period in December.

This year I made less use of unit tests and more use of a debug variable to run either the real input or the test input. I only used unit tests where I needed to find corner cases.

In a reversal of what I mentioned above, some of the problems I solved this year taught me how to solve some problems I’d left undone in previous years and, when I had time, I went back and worked on some of those.

After 25 Dec, I wanted to get to 200 stars before the end of the year, so I did some of the early 2017 problems as well in order to get there.

I’ll leave you with my solutions for Day 1 in Go, Python, and Ruby:

"""Solution to Advent of Code 2022 Day 1: Counting Calories."""

def process_elves(calorie_file: str) -> list:
    """Go through our input to create a list of calorie sums."""
    elf_sum = 0
    calorie_list = []
    with open(calorie_file) as input_file:
        for this_line in input_file:
            if this_line != "\n":
                elf_sum += int(this_line)
            else:
                calorie_list.append(elf_sum)
                elf_sum = 0
    # account for the final elf
    calorie_list.append(elf_sum)
    return calorie_list

def find_top_3_calorie_sum(elf_cals: list) -> int:
    """Take in a list of elf calories, sort, and sum the top 3."""
    elf_cals.sort(reverse=True)
    return elf_cals[0] + elf_cals[1] + elf_cals[2]

if __name__ == " __main__":
    elf_calories = process_elves("../input.txt")
    max_calorie_elf = max(elf_calories)
    print(f"The elf with the most calories is carrying {max_calorie_elf} calories.")
    top_three_cals = find_top_3_calorie_sum(elf_calories)
    print(f"The top 3 elves are carrying {top_three_cals} calories.")

The Go and Ruby solutions benefit from the fact that I’ve now already seen parts 1 and 2 of the problem and can code with that in mind.

// Solution to Advent of Code 2022 Day 01 - Calorie Counting

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

// ParseElves returns the input file if it contains multiple lines of text
func ParseElves(fileName string) ([]int, error) {
    inputSlice := make([]int, 0)
    file, err := os.Open(fileName)
    if err != nil {
        return inputSlice, err
    }
    scanner := bufio.NewScanner(file)
    calorieSum := 0
    for scanner.Scan() {
        thisNumber, _ := strconv.Atoi(scanner.Text())
        // fmt.Printf("Number in loop: %d\n", thisNumber)
        if thisNumber != 0 {
            // fmt.Printf("not a 0!")
            calorieSum += thisNumber
            // fmt.Printf("calorieSum %d\n", calorieSum)
        } else {
            inputSlice = append(inputSlice, calorieSum)
            calorieSum = 0
        }
    }
    err = file.Close()
    if err != nil {
        return inputSlice, err
    }
    return inputSlice, nil
}

func main() {
    elfCalories, err := ParseElves("../input.txt")
    if err != nil {
        // fmt.Printf("Error%v\n", err)
    }
    // fmt.Printf("Elf Calories: %v\n", elfCalories)
    maxCalories := [3]int{0, 0, 0}
    for _, elfCalorieTotal := range elfCalories {
        if elfCalorieTotal > maxCalories[0] {
            temp := maxCalories[0]
            maxCalories[0] = elfCalorieTotal
            tempTwo := maxCalories[1]
            maxCalories[1] = temp
            maxCalories[2] = tempTwo
        } else if elfCalorieTotal > maxCalories[1] {
            temp := maxCalories[1]
            maxCalories[1] = elfCalorieTotal
            maxCalories[2] = temp
        } else if elfCalorieTotal > maxCalories[2] {
            maxCalories[2] = elfCalorieTotal
        }
    }
    fmt.Printf("The elf with the most calories has food worth %d calories\n", maxCalories[0])
    partTwoTotal := maxCalories[0] + maxCalories[1] + maxCalories[2]
    fmt.Printf("The elves with the top 3 most calories have food worth %d calories", partTwoTotal)

}

# Solution to 2022 Day 01 - Calorie Counting

def input_per_line(file)
  File.readlines(file, chomp:true)
end

elf_calorie_list = input_per_line("../input.txt")
calorie_per_elf = elf_calorie_list.map(&:to_i).slice_when {|i, j| j==0}.to_a
elf_sum = []
calorie_per_elf.each do |item|
  elf_sum.append(item.sum)
end
elf_sum.sort!.reverse!

puts "The elf with the highest amount of calories is carrying #{elf_sum[0]} calories. "

puts "The top 3 elves with the highest amount of calories are carrying #{elf_sum[0]+elf_sum[1]+elf_sum[2]} calories. "

Software I used for Programming in 2022

Eric Mesa — Fri, 23 Dec 2022 00:12:58 +0000

Python

This year I really worked a lot on Python web technologies so I came to appreciate all the work that the JetBrains team does to make all the little things (like running Django test server commands) incredibly easy. I essentially did all my Python development in Pycharm. I’ve had access to the paid JetBrains suite because of the work I’ve done for my open source project: Extra Life Donation Tracker. Since development has slowed a bit on there, I may not be able to renew the subscription. If that’s the case, there’s a big chance that I’ll start saving up some money for a Pycharm Professional license. The only real exception to using Pycharm for programming was when I was editing code on a server. There I would use vim or nvim (more on that later).

PyCharm Semantic highlighting

Ruby

Just as last year, all my Ruby code was for Advent of Code. I used Rubymine. I, therefore, get a lot less out of Rubymine than I might if I were developing real projects in Ruby.

Go

While a good chunk of my Go programming was for Advent of Go, I did give a shot at programming my DNS updating project in Go. Things didn’t go well since it JSON is a lot harder with Go than Python. I really love how Goland, which I used for AoC and the DNS project, knows about the standard libraries and will add imports for me if I use it within the code. If I lose access to the JetBrains toolbox, I hope I can configure VS Code, Kate, or Nvim to do something similar.

Programming Language independent

I actually didn’t use Kate much this year. Most of my Python code was part of a project large enough to involve Pycharm or small enough to do in vim or nvim. I believe I did use it a bit early in the year for Perl and Haskell in Advent of Code.

Kate Editor in 2022

I’d previously been using Mu to program CircuitPython for the various Adafruit boards I own. But it was pretty barebones and not a joy to use. Then I saw John Parks (of Adafruit) using Atom on an Adafruit video. I found out that it had plugins to connect to the Adafruit boards and work just as well with CircuitPython as Mu did, but in a more modern interface. I used it to work with my MagTag and Funhouse boards and all was well. (But hold that thought!)

Then in June I decided to finally give VS Code a try. Whenever Michael Kennedy (of Talk Python and Python Bytes) asks folks what editor they use, it seems to be a tie between Pycharm and VS Code. After using it for a while, I was a bit on the fence about whether I preferred it to Kate for small projects.

But then in June I found out that Github was sunsetting Atom. In retrospect, this was not surprising since Microsoft owns Github. Microsoft had developed VS Code as a follow-on (a fork?) of Atom, so why maintain two codebases? (Another article about the transition) Luckily for me, there’s a VS Code Circuit Python add-on. I have used it a few times. It’s not as easy to reconnect a board to the serial terminal window as it was in Atom, but overall it works very well for developing CircuitPython. I would *love* to see Adafruit throw some developers at this, but I think both they and Arduino see the future in web-based IDEs.

VS Code with Circuit Python

I got into JetBrains’ Fleet beta preview. Fleet is their answer to VS Code and the interface looks more like VS Code than a typical JetBrains IDE. I made a video where I took a look at Fleet.

JetBrains Fleet

Even though this blog post is more about what I used, than about news, here’s some more interesting stuff in the Atom/VS Code realm:

If VS Code is not your thing, some of the folks who were mad that Atom was discontinued decided to work on a new IDE called Zed. Up until recently, you couldn’t use it. It’s currently on a wait-listed beta. It looks like the devs are going to go with an open core model which is not my favorite. But I guess that’s probably not so different than Pycharm Community and Pycharm Professional.

Also, VS Code is apparently developed somewhat like Google’s Chrome. It’s mostly open source and then there’s some proprietary Microsoft stuff added on top. So, if you want the VS Code equivalent of Chromium, check out: https://vscodium.com/

Last year I mentioned an issue I was having when launching vim, especially when I had a Python virtual environment enabled. Turns out that was due to using powerline (or at least because I had it installed at the system level?). I switched to using vim-airline and that fixed the issue. It also made neovim stop complaining every time I launched it. This allowed me to start using neovim in favor of vim.

Neovim 2022

My next steps are to setup LSP (language server protocol) (maybe with https://github.com/autozimu/LanguageClient-neovim or maybe it’s built in with the last nvim releases?), and https://github.com/nvim-lualine/lualine.nvim. And once I get that configured, I want to use Ansible to propagate it out to all my computers, servers, and laptops.

Git

When it comes to git-related utilities and sites, there was only one new thing I started using – pre-commit. I set it up for some of my repos to check things like Python import sorting, yaml file syntax, and so on. It helps to minimize the diffs in commits to only what has truly changed.

I admit that I mostly forgot about the existence of gh this year. I only remembered it when I ran an update and saw that it was one of the packages updated. When interacting with Github, I mostly used the site.

I continued to use Github Actions to automate aspects of repository maintenance, including generating release notes for some of my repos.

I continued to use a local instance of Gitea to maintain my private git repos.

Mentioned in prior years, but not used this year

MS Visual Studio for C#/Unity

This year I didn’t do any video game development, so I had no need for MS Studio or Unity.

Drone

Since I mostly use Github Actions and I didn’t work on the package that I do use Drone for, I didn’t really make any use of it this year.

As I mentioned above, I switched over first to Atom and then to VS Code for my Circuit Python coding needs.

GitQlient

I’m not even sure if this project is still in development, but until I stop using JetBrains software, I won’t really have a need for it anymore. I may take it off the list next year.

GitKraken

Since I use GitKraken when I’m programming Unity on Windows and I didn’t do any video game programming, GitKraken didn’t really get any use.

Arduino

I generally prefer to program in CircuitPython so I didn’t really use the Arduino IDE this year. I’m excited that the new UI is finally out of Beta, but I don’t know when I’ll next use it.

Programming Update: Nov 2022

Eric Mesa — Thu, 01 Dec 2022 00:21:34 +0000

November was not a huge programming month for me. On the weekends I was a little more focused with family stuff and videogames. But I did manage work on a couple projects.

Ever since 2010,I’ve been been using Python to automatically post my top 3 artists to Twitter. In 2020, it even became my first package on Pypi. With activity picking up on Mastodon, I ported the code over to that site. I also used the opportunity to clean up the code bit to my more modern coding standards. I haven’t created a package yet, but may soon enough.

I also did some work on my Extra Life Donation Tracker. I’d pulled out the API so that others could build on it, but, as a result, I was creating a Team object from the API rather than the inheritance version. I did a workaround to make it work, but I’m going to have to work at the code a bit more to make it less clunky.

Next month – Advent of Code!!

Review: Data Visualization with Python and JavaScript: Scrape, Clean, Explore & Transform Your Data

Eric Mesa — Fri, 11 Nov 2022 00:19:00 +0000

Data Visualization with Python and JavaScript: Scrape, Clean, Explore & Transform Your Data by Kyran Dale

My rating: 4 of 5 stars

While a book about web technologies is undoubtablely going to get out of date (especially when Javascript is involved), I would definitely recommend this book if you want to do some data visualization either as part of your job or for an undergrad, grad, or PhD project. While I would probably use FastAPI rather than Flask, I heard recently that the Javascript library the author uses, D3, is still one of the best in class libraries for this kind of work.

The author guides you through the process by building a website to visualize Nobel Prize winners. The early steps where the author teaches you how to obtain and how to clean data are very important and, to some extent, will never go out of style. The same can be said of the author’s section explaining how to select the best visualizations.

It’s very well written and I highly recommend.

View all my reviews

Review: Flask Web Development: Developing Web Applications with Python

Eric Mesa — Thu, 10 Nov 2022 00:18:00 +0000

Flask Web Development: Developing Web Applications with Python by Miguel Grinberg

My rating: 5 of 5 stars

I read the second edition of the book

I’ve read lots of books covering web frameworks or GUI programming (both involve UI design and a different workflow where you’re often waiting for user input), but this one is one of the best I’ve ever read. While it’s traditional for a book to culminate in a blog or social media app (and this one does it too) there’s something about the way Grinberg writes that makes it so much more approachable. Also, something only more modern books can do, he has a github repo with all the code with commits that match different sections of the book.

I feel incredibly confident that I’ll be able to write and debug flask applications after having read this book. Highly recommend if you’re a web programmer who is doing to work with the flask web framework.

View all my reviews

Programming Update: October 2022

Eric Mesa — Fri, 04 Nov 2022 01:29:20 +0000

As October came around, it was time to get ready for Hacktoberfest. I’ve been participating for the past few years and I love the fact that DigitalOcean supports this project which gets more people to contribute to free and open source software.

In the past, I’ve often contributed to my Extra Life Donation Tracker. Since the program is pretty mature at this point, most of the issues I have would have taken me too long, especially with how busy I’ve been with non-programming projects lately. So I dedicated my efforts to helping with some quality of life issues for the Prophecy Practicum (Django Version) that I’ve coded up for my friend.

As a refresher, this is a project I made for a friend to automate a bunch of tasks for his spiritual practice. These folks seem to be doing the same thing, based on how he described it to me when we were figuring out how the Django project would work. Part of the way he runs it (and maybe this is key to the practice in general) is that each pair is randomized weekly. I created two random lists and used zip to create pairs, but unfortunately, in some cases (especially with an odd pair) the way I’d programmed it led to the person being paired with themselves. So that was my first important fix during this month.

Next was figuring out how to add in rich text support (bold, italics, underline, etc). I ended up using the ckeditor, as that seemed to require the least involved changes to the code. Then was a request to bring back the ability to save a draft to work on later.

Finally came something that I’d learned about while reading Flask Web Development – flash messages. Known in Django as the Message Framework, those are those messages that show up when you’ve succeeded at creating a post on a social media website, for example. It’s the web version of OS messages (OSX’s Growl, for example). Next up for that feature is figuring out how to make the “X” buttom make it disappear.

I found time during an evening, while watching a comedy special with Danielle, to do the Advent of Code 2016 Day 14 in Python. I’ve gotten pretty good at hash-based problems and this one wasn’t too bad once I sorted out the regular expressions. It was fast enough in Python (even with a naive implementation for part 2. When I get back to this for the other languages I’m using for 2016 I’ll take another look and see if there’s anything I can optimize with the algorithm. However, overnight I began to wonder if it was more optimized in Python to use a regex or the built-in x in y syntax. So I used cProfile to check and found that it was seven times faster than the regex! For part 1 it was 7 seconds vs 1 second.

As often happens, this got the Advent of Code bug to bite me again and I did a few more days before the end of October. Day 15 had us simulating a carnival game – a kind of rotating pachinko. I spent at least an hour trying to figure out how to do it mathematically, but eventually gave up and just simulated the game. I tried putting a capsule in each second until I reached a time where the capsule went all the way through.

Day 16 involved creating a checksum for data. I remembered having to figure out how to work with bits in a prior Advent of Code, but for this problem it was easier to just treat it as text and implement a text version of an XOR.

I skipped Day 17 as it was another puzzle where I had to move around the room and I am still not sure how to work on those. Day 18 was a very simple algorithm that kind of reminded me of a simplified Conway’s Game of Life where you’re only considering one row for your next evolution step.

Day 19 took me a few tries to get the setup and algorithm working for part 1. But part 2 introduces a circle that’s constantly changing shape and, while I got a hint on Reddit for how to think about the circle, I wanted to keep moving rather than getting stuck trying to figure out part 2.

Just a couple nights before the end of October I started on Day 20. However, I implemented an overly inefficient algorithm that crashes Python when I run it. I’ll need to revisit the code to figure out where I went wrong.

I also finished a few programming books this month. As I mentioned before, I finished Flask Web Development, 2nd Edition. I like reading various books about Python web technologies because each one seems to inform my knowledge of the other and strengthen my ability to code. I’ve blogged before about how there’s been a back-and-forth for me between Django, FastAPI, and Flask. That was one of the best well-written programming books I’ve ever read. It flowed very well and I intend to use it for a future flask project. I also finished Data Visualizaiton with Python and Javascript. I want to use what I learned there to create a dynamic website for viewing some of my end of year stats – such as with the music I listen to. We’ll see, but it might come some time in 2023.

Finally, of all the programming articles I read in October, the one that stuck in my head was about the Rust developers updating the style guide. I am a frontline supervisor for programmers now, but I used to be a programmer before. Style guides never gelled with me until I really started to get into Python and trying to make sure my code was all PEP-8 compliant. Now that I see the value of a style guide (especially one that can be applied via a pre-commit hook, it was interesting to read about how the Rust developers were evolving their guide to go along with the evolution of their language.

Programming Update: Sept 2022

Eric Mesa — Sun, 02 Oct 2022 21:08:51 +0000

This month I wanted to practice Go outside of Advent of Code puzzles. So I decided I would port over my Dreamhost DNS updating script from Python to Go. This would have the advantage of being a compiled program. Every time I update Python on my system, the virtual environment points to the wrong Python version and my program breaks. But, boy is parsing JSON in Go (at least with the built-in JSON tools) a real pain in the butt. I have to make a struct to hold and parse the data, but it comes back from Dreamhost as a 1-key dictionary holding an array of dictionaries. After a few hours of trying to figure out how to get Go to parse the JSON I was still unable to get the struct right. I may do a little debugging to see if I can figure it out before searching for any simpler JSON libraries.

That’s all the programming I did in September since I was a bit busy with some other hobbies and family stuff. But with Hacktoberfest in full swing in October, I fully expect to do a decent amount of programming in that month.

Programming Update: Aug

Eric Mesa — Wed, 31 Aug 2022 23:42:58 +0000

August was a programming-filled month for me. It focused entirely on Python and I mostly continued working on established projects. Let’s jump in!

Amortization

I wanted to re-calculate the amortization table for my home loan for the first time in about a year. As a refresher, I created this program (vs using Excel or an online form) because we are not consistent in the amount of extra principal payments we make. For example, if I get a bonus at work, I might throw all of that bonus into the loan payment. So this program takes variable extra payments into account when creating the amortization table.

Since I hadn’t worked on it in a year, I had a new Python version and needed to recreate my virtual environment. This led me to learn that numpy had removed their financial methods from their module. I use the numpy financial methods to calculate a straight-ahead amortization table in order to calculate the interest saved by paying extra. So I had to change my imports to fix that.

I also finally used the rich module to create a new, pretty table for the CLI output. It really is MUCH nicer than my previous attempt at using the “\t” escape to make a table.

Part of the CLI amortization table

Finally, I made a few minor refactors suggested by the Sourcery plugin.

Advent of Code 2016 Day 12

I skipped ahead to the Aoc Day 12 problem and solved it with Python. I usually do very well with these assembly language emulator problems. This one was slightly more difficult than usual. At first I tried to use functions (better for testing) but the way it was setup made it easier to just do it all in main. I did get some practice with Python 3.10’s new match-case statement, making it much nicer to read than an if/else chain.

"""Solution to Advent of Code 2016 Day 12: Leonardo's Monorail."""

def input_per_line(file: str):
    """This is for when each line is an input to the puzzle. The newline character is stripped."""
    with open(file, 'r') as input_file:
        return [line.rstrip() for line in input_file.readlines()]

if __name__ == " __main__":
    our_input = input_per_line('../input.txt')
    a, b, c, d, = (0, 0, 0, 0)
    counter = 0
    while counter < len(our_input):
        # print(f"{counter=}")
        # print(f"{a=}, {b=}, {c=}, {d=}, ")
        components = our_input[counter].split()
        # print(components)
        instruction = components[0]
        x = components[1]
        y = 0
        if len(components) == 3:
            y = components[2]
        match instruction:
            case "cpy":
                match x:
                    case "a":
                        left_side = a
                    case "b":
                        left_side = b
                    case "c":
                        left_side = c
                    case "d":
                        left_side = d
                    case _:
                        left_side = int(x)
                match y:
                    case "a":
                        a = left_side
                    case "b":
                        b = left_side
                    case "c":
                        c = left_side
                    case "d":
                        d = left_side
                counter += 1
            case "inc":
                match x:
                    case "a":
                        a += 1
                    case "b":
                        b += 1
                    case "c":
                        c += 1
                    case "d":
                        d += 1
                counter += 1
            case "dec":
                match x:
                    case "a":
                        a -= 1
                    case "b":
                        b -= 1
                    case "c":
                        c -= 1
                    case "d":
                        d -= 1
                counter += 1
            case "jnz":
                match x:
                    case "a":
                        number = a
                    case "b":
                        number = b
                    case "c":
                        number = c
                    case "d":
                        number = d
                    case _:
                        number = int(x)
                if number != 0:
                    counter += int(y)
                else:
                    counter += 1
    print("Part 1:")
    print(f"{a=}, {b=}, {c=}, {d=}")
    a, b, c, d, = (0, 0, 1, 0)
    counter = 0
    while counter < len(our_input):
        # print(f"{counter=}")
        # print(f"{a=}, {b=}, {c=}, {d=}, ")
        components = our_input[counter].split()
        # print(components)
        instruction = components[0]
        x = components[1]
        y = 0
        if len(components) == 3:
            y = components[2]
        match instruction:
            case "cpy":
                match x:
                    case "a":
                        left_side = a
                    case "b":
                        left_side = b
                    case "c":
                        left_side = c
                    case "d":
                        left_side = d
                    case _:
                        left_side = int(x)
                match y:
                    case "a":
                        a = left_side
                    case "b":
                        b = left_side
                    case "c":
                        c = left_side
                    case "d":
                        d = left_side
                counter += 1
            case "inc":
                match x:
                    case "a":
                        a += 1
                    case "b":
                        b += 1
                    case "c":
                        c += 1
                    case "d":
                        d += 1
                counter += 1
            case "dec":
                match x:
                    case "a":
                        a -= 1
                    case "b":
                        b -= 1
                    case "c":
                        c -= 1
                    case "d":
                        d -= 1
                counter += 1
            case "jnz":
                match x:
                    case "a":
                        number = a
                    case "b":
                        number = b
                    case "c":
                        number = c
                    case "d":
                        number = d
                    case _:
                        number = int(x)
                if number != 0:
                    counter += int(y)
                else:
                    counter += 1
    print("Part 2:")
    print(f"{a=}, {b=}, {c=}, {d=}")

ELDonationTracker

A while back I broke out the Donor Drive API code in case someone wanted to access the Donor Drive API without the burden of my Extra Life code or GUI. I ran into a dependency hell issue between the two projects and it took me a few weekends to get thing working correctly. Now I can finally continue innovating on the project.

ClanGen

My oldest child got obsessed with the Warriors series after her teacher introduced her to it near the end of the last school year. From what she’s described, it’s basically Game of Thrones, but cats and written for a Middle Grade reading level. On YouTube she found out about the ClanGen program which is basically a simulator that takes place in the Warriors universe. I wanted to make some improvements to the way the data is stored – moving it from CSV to JSON-based. The project is fast-moving which makes it hard to get that PR request in, but I’m trying to get these updates in.

FastAPI and MongoDB Class

I took an awesome class (and wrote up a review) where I learned a lot about how to work with MongoDB and the beanie ODM.

Civ VI Play by Cloud Webhook

The greatest amount of work and the most passion I had for coding was with this project. First, I wrote code to sort the table on the index page so that it would go from oldest to newest games, making it easy to see which games were the most delinquent. Then I decided it would be fun to also calculate the average turn length and display this on the index page. I suspect it will be fun to see the contrast there when Kaira goes back to school and Dan and Dave potentially play dozens of turns per game per day as they were doing last year. As I continued to think about interesting things I could do with the user-facing aspect of the page, I decided to make it so that a winner could be set.

As part of the user-facing pages and trying to make them more AJAX-y, I learned a lot about HTMX. I like it a lot as a way to do interactive pages without needing to learn Javascript or a JS Framework. It allows me to just focus on Python for all the logic and a little Jinja2 and HTMX for interactivity.

I also decided, as I was thinking about my endpoints more critically, that I would change the Matrix blame command to only consider active games, so I made the changes to implement that.

Finally, as a consequence of the class I took this month, I moved the data storage from a few JSON files on disk to MongoDB via the free Atlas Cloud MongoDB tier. I had a lot to learn about how MongoDB works in relation (no database pun intended) to what I was doing before. In a lot of ways it has simplified my endpoint code. And, via the database services I’ve written, has helped make a lot of the organization of data more explicit. I’m having some slight growing pains around the fact that changing fields is a little more problematic than when it’s just JSON following whatever random structure I want to use, but I think it will lead to a more responsive site, particularly if the number of games grows. As a result of using beanie for MongoDB, I also started using async all over my code. I’m not sure if I’m being inefficient with it, but it’s making the Matrix code make a bit more sense. Also, the library I’m planning on using for Discord is async, so it’s good to get used to it now.