Forem: Hunter LaFaille

WizardMirror: A lightweight, native alternative to MagicMirror2

Hunter LaFaille — Wed, 29 Jan 2025 04:52:31 +0000

Like many this year, learning Zig was part of my goals for the year. I think I've largely accomplished that with a project I'm particularly proud of, even with as little user facing features as it currently has.

https://github.com/Kerosene-Labs/wizardmirror

WizardMirror plans to be a lightweight and native re-implementation of the core features of MagicMirror, with none of the Chromium. At its core lies an SDL-based rendering engine written in Zig, a networking stack built on libcurl, and an RSS parser written with libxml2.

Currently, 90% of the work is going into the engine, getting the foundational pieces operating well enough where we can start drawing widgets (widgets are pre-made, composable components). Right now, we can pull RSS files, parse them, and display them utilizing our rem based scaling (with rudimentary HiDPI support!).

I'd love any feedback. I'm sure there's leaks, the caching isn't optimal, but it's cool and I'm proud.

Espresso; it's Go time

Hunter LaFaille — Mon, 30 Sep 2024 23:07:45 +0000

I've spent the passed two weeks rewriting my Rust based, no bullshit Java build tool in Go and things progressed much faster. Espresso is faster at runtime and more portable. Espresso also was also recently able to compile and package it's first project, that being my other project Kindling.

I would love any feedback I can get on Espresso. There's quite a few features that are missing like transient dependency resolution (right now they're declared at the package level but just ignored). The package registry has also changed in philosophy somewhat. Instead of being a simple web API, Espresso registries are now zip archives containing a file structure. This means, if you can host a static zip file, you can host an Espresso registry.

One more quick thing, Kerosene Labs has also filed Articles of Organization in our home state to become an LLC. :)

https://github.com/Kerosene-Labs/espresso
https://github.com/Kerosene-Labs/espresso-registry
https://github.com/Kerosene-Labs/kindling

Building a web server with no dependencies in Java

Hunter LaFaille — Thu, 08 Aug 2024 16:04:51 +0000

I've been working on a hobby project for a few months, an MIT licensed API gateway designed to be independent of any particular vendor. I think it's going quite well, to be honest. As my code base has grown, I've seen opportunity for improvement around the core, that being the HTTP server. Spinning out the core HTTP server into its own micro-framework seemed like a logical solution (and a great learning exercise!).

Introducing Kindling, the fuel that'll ignite your application. Kindling is based on the standard Java 21 library, with no dependencies. It's designed to be programmable, without using any magic.

Here's a simple Hello World with Kindling:

package io.kerosenelabs.kindling;

import java.nio.file.Path;
import java.util.HashMap;

import io.kerosenelabs.kindling.constant.HttpMethod;
import io.kerosenelabs.kindling.constant.HttpStatus;
import io.kerosenelabs.kindling.exception.KindlingException;
import io.kerosenelabs.kindling.handler.RequestHandler;

public class Main {
    public static void main(String[] args) throws KindlingException {

        KindlingServer server = KindlingServer.getInstance();

        // test request handler
        server.installRequestHandler(new RequestHandler() {
            /**
             * Tell the server what type of request this handler can work with
             */
            @Override
            public boolean accepts(HttpMethod httpMethod, String resource) throws KindlingException {
                return httpMethod.equals(HttpMethod.GET) && resource.equals("/");
            }

            /**
             * Do your business logic here
             */
            @Override
            public HttpResponse handle(HttpRequest httpRequest) throws KindlingException {
                return new HttpResponse.Builder()
                        .status(HttpStatus.OK)
                        .headers(new HashMap<>() {
                            {
                                put("Content-Type", "text/html");
                            }
                        })
                        .content("<h1>Hello from Kindling!</h1>")
                        .build();
            }
        });

        // serve our server
        server.serve(8443, Path.of("mykeystore.p12"), "password");
    }
}

Sending a CURL request to the server yields this response:

> GET / HTTP/1.1
> Host: localhost:8443
> User-Agent: curl/7.88.1
> Accept: */*
> 
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
< HTTP/1.1 200 OK
< Content-Type: text/html
* no chunk, no close, no size. Assume close to signal end
< 
* TLSv1.3 (IN), TLS alert, user canceled (346):
* TLSv1.3 (IN), TLS alert, close notify (256):
* Closing connection 0
* TLSv1.3 (OUT), TLS alert, close notify (256):
<h1>Hello from Kindling!</h1>

...pretty cool, right?

There's a few bugs, like Content-Length being missing in the response.

Announcing Espresso; a different kind of Java build tool.

Hunter LaFaille — Mon, 25 Mar 2024 13:42:56 +0000

I've constantly fought Gradle for as long as I've been writing Java. I remember when I first started writing Java, I didn't actually use a build tool (just the built in builder in Eclipse).As I've gotten into the Java world professionally, which means writing more tests, I've realized how god awful Gradle is with it's convoluted plugins that have a needle-in-a-haystack like feel to it.

I'm confident Gradle has it's place in the world; those organizations who need complicated build processes. The problem is, every code base I've ever worked on could be built by a much simpler tool.

This is why I built Espresso. Espresso is a build tool for Java (written in Rust) that focuses on simplicity, speed, repeatability and ease of configuration. It's still a huge work in progress (and served as a project for me to finally learn some Rust). Features like including dependencies into the built .jar are missing (although you can fetch them from the Espresso Registry). Espresso is inspired by Cargo and Go.

https://github.com/hlafaille/espresso

Espresso also does away with using Maven Central, a repository owned by Sonatype, in favor of an open source and transparent approach similar to Nixpkgs and Winget (https://github.com/hlafaille/espresso-registry).