Forem: Brandon Charest

How I Stopped Over-Thinking and Started Shipping

Brandon Charest — Mon, 29 Dec 2025 16:30:11 +0000

The Analysis Paralysis and the Cycle of Abandoned Projects

I found myself constantly stuck trying to create new projects and had perfected the art of quickly killing it by over-analyzing. Each time I came up with a new idea I found myself constantly stuck trying to create new projects and had perfected the art of killing them before they lived. Each time I came up with a new idea, I'd get lost in the smallest details.

You know when those details mattered? Never. Because I never finished any of the projects.

After reflecting on this problem for a little while, I wondered what if I built just a completely ridiculous project, something that had no serious value and was strictly just for fun.

The "Stupid" Idea: Weaponized Insults

The idea is simple: a user inputs a password, and the API returns a security score... and an insult.

Try it yourself: roastmypassword.com

Yup, that's it. No stakes, no pressure, just a fun little project.

The Over-Engineering Trap

I still wanted to learn something along the way, and since I use Python, JavaScript, and Java daily for work, I decided to implement the API in Rust. I have been wanting to learn more about the language for a while, and thought this would be as good a time as any.

The Trap

No sooner did I start, I caught myself thinking too far ahead...

"Whats the best structure I should use so I could scale this easier in the future?"
"What if I need a database?
"What kind of database?"

..and various other thoughts about clever ways I could implement the insult generator.

Breaking Free

This time I made myself remember, all these thoughts are not getting me any close to finishing this. So I literally stopped worrying about what could be needed and just started writing only what I needed right now.

Embracing the "Good Enough"

Giving myself permission to be lazy was the hardest part of the project. But once I did all the technical decisions became obvious. I did not need a React SPA application with Redux state management, or a database to store insults, or anything complex. I needed a function that took in a string and returned a string.

Language: Rust (because I wanted to learn it and insult users blazingly fast)
Backend: AWS Lambda
Frontend: A single HTML file. No build steps, no node_modules.

The code is simple. It uses the zxcvbn crate to calculate the strength of the password, and a simple "Mad Libs" style insult generator to construct the insult.

The $0.00 Deployment

In the past, this is where I would have spent the next few hours or days, trying to find a clever solution with my insult generator. I would have tried to come up with a more scalable solution.

Instead, I deployed it.

The frontend is just a index.html file hosting on Cloudflare Pages. The backend is a Rust binary running on Lambda. It costs me $0.00/month to run.

Is it perfect? No, in fact I am almost positive I have some spelling mistakes and bugs. Does it scale to millions of users? Probably not, (but I'm sure Rust helps with that). Does it make me laugh? Yes.

Moral of the Story

As engineers we are trained to think about the edge cases, scalability, performance, architecture patterns, and "future-proofing".

(I'm looking at you Database Abstraction Layer. You know, just in case I decide to migrate from PostgreSQL to MongoDB to Cassandra next Tuesday)

But for a side project, future-proofing is just procrastination with extra steps.

By choosing to build something "stupid", I was able to make that mental shift and removed the pressure to be "smart". I learned more about Rust, and managing my own deployment to AWS in a weekend then I would have if I spent the next few days/months watching more tutorials and researching to build a more "serious" project. Not everything needs to be perfect or serious, sometimes its nice to just have fun.

Your turn: Stop over-thinking. Start shipping. Have fun.

Getting Started With Kafka Using Docker

Brandon Charest — Wed, 29 Jun 2022 18:59:38 +0000

Getting Started

Before we do anything let's make sure we have Docker installed.

Docker Desktop

Docker Desktop is a simple and easy way to manage containers.

What is Kafka?

Kafka is an open source streaming platform that was developed by LinkedIn written in Java and Scala and is now under the Apache foundation.

In simple terms Kafka is a message broker, which helps transmit messages from one system to another in realtime, now I understand that this is a major simplification as to exactly what Kafka is and does but for now this definition will work. To note, there are other products that achieve similar results, some popular ones are Redis and RabbitMQ, each with there own pros and cons that I wont go into here.

We will also be using a service called Zookeeper which is used to manage Kafka cluster, track the node status and maintain a list of topics and messages and manage a bunch of other metadata.

It is possible to use Kafka without Zookeeper by using Kafka Raft Metadata Mode (KRaft). Which is available in experimental mode in Kafka 2.8 and should be ready for production by Kafka 3.3. But for this we are just going to stick with using Zookeeper

Installing Kafka Using Docker

Now that we have Docker and understand a little bit about Kafka we can start.

I like to create a separate folder for all my projects so for this I will call it 'kafka-docker'.

We will be using the following containers.

bitnami/kafka
bitnami/zookeeper

There are other images available for Kafka and Zookeeper and you can use which ever you prefer, I have just chosen these two.

Instead of setting this up manually we are going to use Compose. If you have not used Docker Compose before essentially its a convenient way to work with multiple containers at once using a single YAML config file.

Inside the folder you created, create a YAML file with the following information. By default docker-compose looks for a file called 'docker-config' but you can name it whatever you want.

docker-config.yml

version: "3"
services:
  zookeeper:
    image: 'bitnami/zookeeper:latest'
    ports:
      - '2181:2181'
    environment:
      - ALLOW_ANONYMOUS_LOGIN=yes
  kafka:
    image: 'bitnami/kafka:latest'
    ports:
      - '9092:9092'
    environment:
      - KAFKA_BROKER_ID=1
      - KAFKA_CFG_LISTENERS=PLAINTEXT://:9092
      - KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://127.0.0.1:9092
      - KAFKA_CFG_ZOOKEEPER_CONNECT=zookeeper:2181
      - ALLOW_PLAINTEXT_LISTENER=yes
    depends_on:
      - zookeeper

We do not need anything too special for this config file so we can take this for the documentation found here.

If ports 9092 or 2181 are not available for your system feel free to change them to ports that you have open and available.

Once that file is created its time to use docker-compose to setup our containers for us.

Inside the same folder that has your YAML config file run the following.

Format:
docker-compose -f <nameOfYourConfig.yml> up -d

docker-compose -f docker-compose.yml up -d

Command Breakdown:

docker-compose: Utility used to download/run the containers we defined in out config file
-f: Specify an alternate compose file (default: docker-compose.yml)
docker-compose.yml: Our config file
up: Create and start the containers specified in the config file
-d: Run in detached mode. Containers will run in the background

Once finished let's check that everything is actually running.

docker ps

Command Breakdown:

ps: List all containers

If all went smoothly you should see something in your terminal similar to below.

We did it! We are now up and running with Kafka using Docker!

Connecting to Kafka Shell

With Kafka up and running we can create a connection to it.

Format:
docker exec -it --user <userName> <nameOfContainer> bash

docker exec -it --user root kafka-docker_kafka_1 bash

Command Breakdown:

exec: Run a command in a running container
-it:
- -i: Interactive mode
- -t: Pseudo Terminal
--user: Username of user id
root: Name of the user we are going to login as
kafka-docker_kafka_1: Our container name we want to run the commands on
bash: Open interactive Bash session

If all goes well we should have opened a new Bash session side our Kafka container!

That's A Wrap

At this point you have a fully functioning Kafka instance running inside Docker.

I like to try and keep posts relatively short so I will save going over a little more about what Kafka is, creating topics, and creating some microservices to can interact with each other using Kafka for the next blog post, I am hoping for this to be a small series so be sure to check back!

Terminal: Copy Current Path

Brandon Charest — Wed, 22 Jun 2022 13:28:48 +0000

TLDR:

Create this alias into your .aliases/.zshrc/.bashrc or where ever you store aliases for easier use later.

alias cpwd="pwd | tr -d '\n' | pbcopy && echo 'pwd copied to clipboard'"

Recently I have been spending a little more time using the terminal for work and have had a few instances where I needed to copy the current directory I am in. Now in most cases you could just use the mouse to highlight and copy the directory you need, but I am ~~pretty lazy~~ motivated to try and make this a little easier as I suppose there could be a time where using a mouse is not an option.

Parts Breakdown

pwd: print working directory

$ pwd
/User/(username)

Prints the current directory path you are in.

tr: translate characters

tr -d '\n'

This will copy standard input to the standard output with substation or deletion of selected characters.

The pwd command above will produce the working directory string but it will have a line return character '\n' appended to it.

We use the -d command to signal that we want to delete a character off the string and '\n' to signal which character we wish to delete.

Copying to system clipboard

Depending on if you are on OSX or Windows the copy command could be different

Windows

clip

OSX

pbcopy

this will copy text to the system clipboard (by default).

echo: Writes to the standard output.

echo 'pwd copied to clipboard'

This part is not needed I just personally like to have something in my commands that will tell me that the command was at least executed.

Pipe it all together

All of these above commands are used with a pipe '|' which will feed the 'output' of one command to the next.

So the flow will be the following.

pwd prints out the working directory
That output is now fed to our tr argument which will remove the trialling newline character
finally that entire string will be placed into our clipboard for use with the help of pbcopy/clip.
Then an echo at the very end will just print to the screen that the command has been executed

Final

Now this is far from the only way to do this, I believe a popular way would be to just use xclip but that may take an install and I tried to find a way to use only what is available by default.

I hope that someone may find his useful. What are some of the things you have learned in the terminal that has saved you time/made things easier? Let me know! 😃