j money

Why I Started a Bear Blog

Tue, 16 Dec 2025 01:10:00 GMT

Hello everyone this is my first post on my blog.

I started this because I think it is a good idea to build things in public.

Someone else might learn something.
I might learn something from someone else.
A place for me to put whatever is on my mind.

That's about it!

Stay tuned chat.

A Simple Webring Manager

Wed, 17 Dec 2025 21:00:00 GMT

Some friends and I want to create a webring between our blogs, so I wanted to make a simple tool for people to set up webrings. An admin can go in and add the websites, order them, and send out an embed via email. Since I love Wheel of Time, I'm calling this project "waygates". A waygate will be a webring between websites.

I'm using Go for this project because I want to learn Go. I know, isn't that quite riveting?

I want to keep things simple with a minimal frontend. I'm using Templ with HTML templates. I'm familiar with Blade and Twig files in PHP, so I figured this was a good choice. I'm really pushing the "learning Go" angle for this project. I want to do things that are familiar so my focus is on the language.

For the backend, I'm using the Gin router. I chose this because my favorite drink is a Gin and Tonic. That was sort of a joke but not really. I chose this because it has good middleware support I can add authorization, and it's lightweight. There will be basic login credentials here so users can manage their webrings.

For DB interactions, I'm going to use the database/sql driver and an sqlite3 database. It's better not to over complicate things. I can practice my SQL skills, without needing to add any unnecessary overhead.

Stay tuned chat for more updates.

The Github repository is here.

You Don't Need Project Ideas

Tue, 23 Dec 2025 17:55:31 GMT

Every passionate developer has had a moment where they felt motivated and ready to work on a new project. Then told themselves some variation of the following:

"I want to work on a new project but I don't know what to work on."
"I have trouble thinking of something to work on."
"What is a good project for new developers?"

This is a common thought I have had countless times. But the truth is: the best way to find something to work on is to just start working on something.

By something, I mean literally anything.

Here is an example I was young, bored, and felt like doing something. So I was like what if I just Twitch stream myself coding advent of code. Then I started this blog, and now I work on projects, and now I have a backlog that feels like it will never end.

The moral of the story is the best way to find something to do is to build momentum.

The Shadow Rising by Robert Jordan

Tue, 30 Dec 2025 03:10:00 GMT

this is a spoiler review

I just finished Wheel of Time Book 4: The Shadow Rising, By Robert Jordan. This book is generally talked about as the best book in the series.

This is the first time in the series where we really see "He Who Comes With The Dawn" really tear apart the world. You can see some of the seeds Jordan plants in previous books really come to life here. An obvious example here being the relationship between the Tinkers and the Aiel. The exposure of many of their ideals being the complete opposite to what they once were with Rand's journey through Rhuidean. I also love Lanfear's character and am really interested to see how she deals with her love for Lews Therin later on.

The book was not all perfect, I felt it sort of dragged on in the middle. Lots of chapters with traveling with the Aiel, or Perrin just kind of setting up this fight against the Trollocs. Don't get me wrong, each of these plot lines finished up well, it just took a long time to get there. I also thought the Rhuidean chapter being told backwards was very confusing, but after a summary and a reread I appreciated it.

That being said, this series has been great so far. I am mainly looking forward to more with The White Tower and I am waiting to see how Mat's role expands later on in the series.

Rating: 4 stars

How I Set Up JWT Authentication for Waygates

Tue, 06 Jan 2026 18:07:00 GMT

Here is devlog #2 for the waygates project. This is how I setup JWT authentication in Go using Gin. As always here is a link to the repository on Github.

User authentication consists of three endpoints: /signin, /signout, and /signup.

The /signin endpoint has the following flow:

Check if the email is in our database and grab the hashed password.
Hash the password from the request.
Check if the password from the request matches the password in the database.
Create a JWT token which stores the user ID and store it in a cookie.

Doing this specifically in Go was not much different than other languages. We manage our cookies, request, and response all through the Gin context as seen here. One part of the language I do like is the way Gin handles custom request objects. We were easily able to verify the email without really adding any additional code and it was quite readable.

func (h *AuthHandler) Signin(c *gin.Context) {
	// ...
	c.SetSameSite(http.SameSiteLaxMode)
	c.SetCookie("Authorization", tokenString, 7*24*60*60, "/", "", true, true)
	c.Header("HX-Redirect", "/")
	c.Status(http.StatusOK)
}

The /signup endpoint consisted of the following:

Check if the email already exists.
If not, hash the password and store this user in the database.

With all these database operations I wanted to make a small aside here on how easy it is to query the database with Go. All of my repositories are just wrappers around SQL calls, which means there really is no barrier to entry with this language. Take this function to create the user in the /signup endpoint. It's literally just SQL.

// Create a new user in the database.
func (r *UserRepository) Create(user models.CreateUser) (models.User, error) {
	query := "INSERT INTO users (email, username, password) VALUES (?, ?, ?)"
	
	result, err := r.db.Exec(query, user.Email, user.Username, user.Password)
	if err != nil {
		return models.User{}, err
	}

	id, err := result.LastInsertId()
	if err != nil {
		return models.User{}, err
	}


	return models.User{
		ID: int(id),
		Email: user.Email,
		Username: user.Username,
		Password: user.Password,
	}, nil
}

The /signout endpoint clears the JWT token stored in the cookie as shown here:

// Signout handles user signout requests by clearing the Authorization cookie.
func (h *AuthHandler) Signout(c *gin.Context) {
	c.SetCookie("Authorization", "", -1, "", "", true, true)
	c.Header("HX-Redirect", "/signin")
	c.Status(http.StatusOK)
}

Significant progress on waygates this time around. So far what I like about Go is how verbose it is and easy to debug. I will have another post soon detailing this, but it makes typical debugging just part of writing the code. The docs for Go have been incredibly helpful and this language reads well.

blogkitty: A RSS Feed Manager in Discord

Fri, 09 Jan 2026 16:37:00 GMT

Hi! I wanted a way to monitor blogs for members in my Discord server, so I created a bot which will monitor RSS feeds into channels with just one command. You can check out the project here!

How it Works

When you run the /monitor [rss-feed] [channel-name] command in Discord, the bot will create a channel with that name and stream any updates from rss-feed into it. To remove the feed you can just delete the channel.

In this article I mostly refer to the feeds being monitored as RSS feeds. However, this works with Atom too!

In my Discord server I have a category called feeds and use these to monitor any sites I am interested in. This is the bot in action:

The logic of the bot is fairly simple and follows this format.

The user will use /monitor command in Discord:
- The feed added by the user will be added to the database.
- A channel will be created to monitor the feed.
Every 10 minutes a cron will run:
- Pull the URL of each feed from the DB using gofeed.
- Compare the most recent GUID of the feed with the one stored in the DB.
- If the GUID has changed, send a link to the new post in the specified channel.

Development

The bot is written in Go on top of the Discordgo library, which provides bindings around the Discord API. I found it unnecessarily verbose when interacting with the session. Take this function which will reply to the user after they use a slash command:

// Replies to the current interaction.
func reply(message string, dg *discordgo.Session, i *discordgo.InteractionCreate) {
	dg.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
		Type: discordgo.InteractionResponseChannelMessageWithSource,
		Data: &discordgo.InteractionResponseData{
			Content: message,
		},
	})
}

It's not all bad, it takes advantage of a lot of the languages benefits by being a very simple library with efficient error handling. It doesn't do much more than wrap API calls and provide types to the API, which is an intended Go-style design. I don't think this library is as polished as discord.js but it worked well for this small application. In the future, I might create a library to better handle slash commands.

I used a sqlite database with Goose to manage the migrations. What's nice about Go is that when querying the database I can just use SQL without an ORM. Here is a simplified example of something used in the code (without all the verbose error handling!).

// Update the GUID of a feed to match the latest post.
func UpdateFeed(feed Feed) (Feed, error) {
	query := "UPDATE feeds SET latest_post_guid = ?, discord_channel_id = ?, feed_url = ? WHERE id = ?"
	
	DB.Exec(query, feed.LatestPostGUID, feed.DiscordChannelID, feed.FeedURL, feed.ID)
	
	return feed, nil
}

For parsing the feeds I used the gofeed library to grab the link to the most recent post. This is a great library which works with both RSS and Atom feeds:

// Gets the latest post for a feed.
func getLatestPost(rssUrl string) (*gofeed.Item, error) {
	fp := gofeed.NewParser()
	feed, _ := fp.ParseURL(rssUrl)
	return feed.Items[0], nil
}

What's Next

In the future I would like to make it so there is a designated feeds channel where each thread is a different feed. This way the server does not get bloated with channels. This bot was a great way to learn about Go and I am having a lot of fun with the language. Contributions and suggestions are always welcome, and I'd love to hear your thoughts!

Go Project Structure and SQL Support

Fri, 19 Dec 2025 02:36:00 GMT

Here is the first devlog for the waygates project! With this first post I cover the initial file structure and database setup. As always, here is a link to the project on Github.

I typically struggle with file structure when learning a new language. It's better to do these types of things right the first time to avoid refactoring later.

I want to use the repository pattern, where we can think of the flow of our code like this:

[ ENDPOINT ] -> [ CONTROLLER ] -> [ SERVICE ] 
-> [ REPOSITORY ] -> [ DB ACCESS ]

When I was a lowly PHP intern I thought that this structure overcomplicated things and was unnecessarily verbose. However, pairing this structure with Dependency Injection really cleans up the project and makes it very easy to read. In case you are not familiar with DI, it is a way to pass our dependencies via the constructor instead of instantiating them in each class.

Here is the directory structure I am starting with:

components/
db/
handlers/
middleware/
migrations/
models/
repositories/
services/
main.go

The next part was setting up the database. I wanted to do this “the Go way” so I decided not to use an ORM. Instead, I will use Go's sql library for queries.

One thing in particular I had an issue with was making migrations and initializing the table. I am using sqlite because I don’t think this table will get that big all it will hold is the users, and the waygates.

For migrations I went with goose because it has support for sql migrations.

Here is the initial users table migration:

-- +goose Up
CREATE TABLE users (
    id INTEGER PRIMARY KEY UNIQUE,
    email VARCHAR(100) UNIQUE NOT NULL,
    username VARCHAR(50) NOT NULL,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- +goose StatementBegin
SELECT 'up SQL query';
-- +goose StatementEnd

Overall, solid first step for the waygates project. I am really liking Go as a language because its unique error checking makes it a lot easier to debug. I also noticed that each library I install is relatively lightweight, and I don't feel overwhelmed like I would in a language like TypeScript.

Next will be some updates on user authentication and htmx.