Hacking the Grepson

Matt and Mike check in again on their progress of making a game. More discussion ensues about preferences, recent games played, and about Defold and Love2D, including some recent efforts made by both.

Matt and Mike continue to discuss more details about the game they're going to make. On this episode the decision of which engine/language/IDE they're going to primarily use is made...sort of.

Our new season, focused solely on making a video game of some sort, continues apace. This is a lengthy one, filled with discussions of game mechanics, likes/dislikes, and potential ideas to follow up on. Matt and Mike don't know what they're going to make yet, but they're getting further into what about games they enjoy (or don't).

For Season 2 of Hacking the Grepson, we're going to make a game! What kind of game? Which platform(s)? What genre/theme/setting? Who knows?! Let's try to start attempting to figure it out.

We've done a hundred episodes of this podcast. Wow. Matt and Mike come to terms with this fact, and perhaps give an idea of what's to come with the next hundred episodes.

You can't always do everything by yourself. That's when you need a group of people! Are those people working towards a common goal? Well, then you might have a team. Matt and Mike, as a team, talk about the benefits of such cooperation.

How much can a developer assume about a user of their software? It's not always immediately clear, but as time has gone on the way that tutorials have presented themselves has changed. Mike uses an anecdote about a recent gaming experience with a friend to open up discussion with Matt on the topic.

Systems and mechanisms usually work, but they don't always. When they don't, what to do? Shoot that trouble, chum! Matt and Mike talk about their magic problem seeking-and-destroying abilities in this episode's discussion.

Gaining knowledge of anything is ostensibly good, but it also potentially brings with it a price to pay. Matt and Mike discuss a very intriguing blog post about the ethical and moral burden that knowledge can bring.

* The Curse of Knowing How, or; Fixing Everything

Teams could be said to be working together in one of two different ways: a desert or forest. What do those terms mean, and what does it mean to move from one to the other? Matt and Mike discuss a series of blog posts from Kent Beck and Beth Andres-Beck that attempt to illuminate these nature metaphors.

* Forest vs Desert

Matt and Mike are often working on things outside of preparing to record this podcast. On this episode, we explore the question: "What are you working on lately?"

An exciting new Roguelike deck-building puzzle game has taken the industry (and Mike (and possibly later Matt?)) by storm: Blue Prince. It's a very light take, development-wise, on the subject matter, but games are a huge inspiration and problem space for programming, so we think it's worth the praise and discussion.

* Blue Prince

* Roguelike

* Deck-builder

Software development loves the concept of binary. On/off, 1/0, true/false, and all that. The way users interact with a system vs the way it works in the code/data area is very similar. Matt and Mike discuss the differences between frontend and backend, and how it can apply to more than just web development.

In general, no one writes much assembly code (let alone raw zeros and ones) anymore, and apps that computers run usually fall into two camps: compiled and interpreted. Matt and Mike try to explain the distinction.

Love this related blog post: https://ntietz.com/blog/python-is-an-interpreted-language-with-a-compiler/

In 2025, LLMs, Machine Learning, and AI are being used in all manner of technology. But how can I, asks the average computer user, take advantage of it? Matt and Mike offer some guidance.

Do you process new information from the bottom-up, or from the top-down? The potential answer to this can be complicated. Matt and Mike use the usual software development to answer the question, but also branch off into everything from woodworking to ecological concerns.

Facades, adapters, interfaces...these are all types of abstractions, a powerful tool in programming to hide a more complex system so that users or consumers can better utilize the power contained underneath them. Matt and Mike peel back the layers.

You could work on a software project without version control. It doesn't impede your ability to change things and deploy. But you'd be working without a net. Matt and Mike dive into the wonderful world of not having to keep both file1.js AND file1a.js.

The final days of Advent of Code 2024 have finally concluded. Matt, Mike, and Richard finish up their discussion of Days 20-25.

* Advent of Code

* Richard's Day 21 notes

* Richard's Day 24 notes