hugozap

How to finish your side project.

2020-04-24T00:00:00Z

It's no secret that finishing a side project is hard.

I've struggled with some side projects and had success with others. In this post, I'll focus on the actions and adjustments that have worked for me.

It's possible to work on and finish side projects even with a busy schedule, the key is to optimize for interruptability. You will be interrupted so instead of counting on having hours of deep work available, it's better to be realistic and make some adjustments to use available time in a better way and reducing the cost of interruptions by having tricks to switch context fast.

A failed side project story #

Maybe you are familiar with a similar situation

At the beginning:

High motivation.
Priority over other tasks.
Working long hours because it's fun.
Desire to work with a new technology
No problem working on weekends.

After some time:

Motivation decreases.
Feels overwheelming.
Harder to justify working on the project when there are other responsibilities.
Other stuff seems more interesting now.
Forgot how to set things up to continue working on the project.
Not sure what I was working on.
Forgetting about the project and archiving it.

The challenges with side projects #

Context switching and high cognitive load is exhausting.
Losing interest/ motivation.
Perfectionism - never ending projects.
Impostor syndrome.
Lack of focus.
Lack of time.
Unexpected life events.

Re framing the goal #

I believe you can set yourself for failure from the start if the goal is not clear.

I've been excited about ideas but later found that I was not really invested in the idea and just wanted to explore a cool feature/tool. It's good to go deeper to your true motivation.

Feeling overwhelmed can also contribute to abandoning the project, I'll talk about small steps and why it's key.

If your track record includes lots of ambitious projects and none of them finished, then starting with something smaller seems like the logical approach.

Pick a small battle, maybe just the key feature first, maybe support for just one platform. Cut off features for the first version, remember that there's a lot of forces against you completing your project so reducing load is important.

The approach #

Now that you have a clear idea of what you want to finish, there's some actions and adjustments to your process that will increase the chance of winning the battle (shipping).

Preparing your environment (painless context switch)
Work in Small steps
Mental warm-up before each session.
Anticipate and expect interruptions.
Changing your physical location.
Writting down the ideas on your mind at the end of the session.

Small steps are key #

I like the idea of not having too many open boxes at the same time, where each box is a task/feature or something that you started but haven't finished yet.

It's demoralizing to wait weeks or months for a win. Small steps give you small wins, it keeps the journey fun. There's less change of feeling stuck.

Geepaw Hill shares excellent resources on the topic of small steps in software.

Warming up before each session to reduce cognitive exhaustion #

Before starting actual work, write about what would be good to achieve in the session. I find this ritual valuable as it helps me figure out the next small step. Writing the project goal (high level) every session is also a good way to switch context and reminding yourself what's it all about.

I'll talk about having a "context" log, where you write the current progress, and what to do next. If you have this file, reading the previous session log let's you resume your work faster.

Immediate context switching #

With the limited amount of mental energy, is crucial to reduce the number of setup tasks required to do a working session on your project. The goal here is reducing the number of small decisions you have to make to have a working environment.

This is one of the most important things for me, and the way I approach it is:

Creating a separated system User on my laptop.
Having an email address only for my project.
Having a "context" file where I log what's currently happening with my project, usually at the end of a work session.

These have been valuable tools for me, let me explain why:

A separate system user for your side project #

By creating a separate user, you automatically have all the operative system tools (calendar/notes/reminders , etc.) available ONLY for your project.

All the files on your desktop will have a relation to your project. This may not seem impressive but think about all the small distractions you find if you use the same user for your personal/work tasks:

Time to find a file (filtering unrelated stuff will bring memories of other things)
Reminders/calendar notifications not related to your project
Dealing with other project setups can be stressful.

I think it was Seth Godin who recommended having a separate laptop for a side project like writing a book. This is an alternative too.

You can add more extreme measures like redirecting distracting sites like news or reddit. If you need to login to one of those sites, it's better to switch user accounts. Try to keep your project user clean.

Having an separate email for your project #

I'm a fan of email as a note taking tool, it's available everywhere, the UI is simple. Having a separate email account lets you capture related notes/ideas/links from any device. This has been useful for me when I'm doing something else and have an idea, or find a resource that can be used to do something I want to incorporate into the project.

Later, when I log in to my project environment I'll get the emails with relevant information, no chance of getting distracted with other stuff.

The context file, (brain dump). #

A context file is just a text file where you add a short summary of the current project status and what's on your mind at the time.

This has been valuable to me, because the act of writing it down helps me have a clear idea of things I could do next and next time I have time to work on my project I'll have a starting point and it reduces the cognitive load which maximizes the session efficiency.

Location #

Going to a library or café (when possible) or event to another room and have a dedicated space for your current side project will make a difference.

Not sure about why, but using the same desk for different work and side projects is not ideal for me. If you can I recommend having a different place that helps you switch context quickly.

Abandoned projects may not be a failure after all. #

Some abandoned projects end up being an inspiration to create something else years later. Maybe you learned something new, explored an idea, or found a problem not possible to solve with the knowledge and resources you had at the time.

It's good to have an open mind and be ok with finding dead-ends, they are powerful teachers.

However, shipping projects is awesome and by reducing scope and anticipating interruptions you will be able to complete your project and release it to the world.

Resources #

For more information about the benefits of a "small step" approach to software development check the excellent resources from Geepaw Hill

Credits #

Illustration by Angelica Delvalle (In case you need art for your company products contact her, she does awesome stuff!)

Thinking in lists

2022-01-01T00:00:00Z

For years, I've experimented with different techniques and tools to help me improve my thinking process. Daily journaling is one of those tools, I initially wrote on a paper notebook but I didn't have the discipline to keep one notebook only for that purpose (always ended up using it for planning work-related stuff).

By creating the habit of daily journaling, I can clear my mind (the best time to do it for me is early in the morning). Sometimes the journaling sessions are short, and other times I spend hours on it.

What I found effective is to move from prose-based journaling to a list-based one.

It looks like this (vague example)

- Goal for this week
    - Learn about topic x
        - What resources should I use?
            - Buy a book?
                - I may have already something on my kindle
                - Who's an authority on the topic?
                - Find book recommendations on Reddit
                - Better to find a video course?
                    - Haven't had much success with those in the past.
						- Why?
							- Too much noise
							- Feels slow
							- Too much variability (depends on narrator skills)
            - Watch youtube videos?
           	 - I've found that for totally new topics, watching a couple of videos gives me some context so I'll start with that.
    - Write that article I've been delaying for so long
        - What's creating resistance and procastination?
        - Outline
            - Start with X
            - Continue with Y
            - End with Z

So the basic idea is that you have a conversation and allow your brain to go to new paths (represented as nested items). This has a few benefits

You can quickly focus on a new idea.
No need to keep a consistent narrative
Going back to a previous idea is easy
No need to have sophisticated tools
Easy to zoom out and see the big picture.

I use Obsidian to keep track of my daily journaling (using the Daily notes plugin). You can use whatever you like and experiment. Some people like to have sophisticated workflows for note-taking. It's easy to get distracted by which technique or tool works and end up in a rabbit hole (I'm sometimes guilty of this).

Anyway, it pays to spend some time clearing your mind and daily writing is a good way to do it.

Using Constraint Solvers with Rust and WebAssembly (Exploration)

2022-10-12T00:00:00Z

Yesterday I spent some time experimenting with linear constraint solvers using Rust and WebAssembly.

(Demo repository)

What is a constraint solver?

The basic idea is that you specify a problem in terms of restrictions. This restrictions should be expressed as linear expressions.

UI Layouts are a good fit for linear constraint systems, because you can express the relations among elements in terms of these linear expressions.

the top of the box2 element should be equal to the bottom of box3
the x position of box4 should be equal to the total width/2
the total width is >= than box2
the total width is >= than box5

When you have the set of expressions you ask the solver to generate a solution and it will try to produce an optimized set of values that satisfy the constraints.

When a variable changes, the solver will re compute the solution again.

Expressing problems as constraints #

I think this way of approaching problems is very interesting and aligned with the current trends of AI assisted workflows, that's one of the reasons I find it useful to improve the problem definition skills and defining constraints is one way to do it.

Simple experiment with WebAssembly #

As part of my Rust and WebAssembly learning journey I like to experiment with topics I find interesting, so let's try to run a solver in WASM and use it from JavaScript.

Creating the rust project #

I used wasm-pack new to generate the starter project for my library. It will export a struct that JS will consume and will contain a method to compute the layout.

Then, I needed to install the cassowary rust crate. At this point I wasn't sure if it would work in Wasm.

(Rust project dependencies)

[dependencies]
wasm-bindgen = "0.2.63"
cassowary = "0.3.0"
js-sys = "0.3.44"

Using the cassowary-rust library #

There's an implementation of the cassowary algorithm to find solutions to a set of constraints.
The high level idea is:

Create a new solver instance
Create variables (with Variable::new())

Our model only has 2 points, each point with a location. Note that we use Variable for the values, because they will be used by the solver.

    let mut names = HashMap::new();
    let window_width = Variable::new();
    names.insert(window_width, "window_width");

    let p1 = Point {
        x: Variable::new(),
        y: Variable::new(),
    };

    let p2 = Point {
        x: Variable::new(),
        y: Variable::new(),
    };

    names.insert(p1.x, "p1.x");
    names.insert(p1.y, "p1.y");
    names.insert(p2.x, "p2.x");
    names.insert(p2.y, "p2.y");

Add the constraints (EQ is the equals operator, there's also support operators for inequalities)

 solver.add_constraints(&[
                p1.x | EQ(REQUIRED) | 0.0,
                p1.y | EQ(REQUIRED) | 0.0,
                p2.x | EQ(REQUIRED) | window_width,
                p2.y | EQ(REQUIRED) | window_width/2.0,
            ])
            .unwrap();

Our constrained system is simple, there are 2 points and the location of point 2 is determined by the value of the window_width variable. If window_width variable changes, p2.y will be updated.

Set known values

We know the window_width variable so let's tell the solver we want to start with a value for the window_width variable (first we add it as editable)

solver.add_edit_variable(window_width, STRONG).unwrap();
solver.suggest_value(window_width, 100.0).unwrap();

To retrieve the calculated values we use the solver get_value method.
Here we populate a hash map with (name,value) pairs.

    let mut result = HashMap::new();
    for (var, name) in names {
        result.insert(String::from(name), solver.get_value(var));
    }

Testing that the solver works #

Let's add a simple unit test to make sure we set the solver parameters correctly

    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn test_calculateLayout() {
            let app = App::new();
            let result = app.calculateLayout(); 
            assert_eq!(result.get("p1.x"), Some(&0.0));
            assert_eq!(result.get("p1.y"), Some(&0.0));
            assert_eq!(result.get("p2.x"), Some(&100.0));
            assert_eq!(result.get("p2.y"), Some(&50.0));
        }
    }

How to return the values to JS? #

With WebAssembly we have different options to return data.

Return an array of bytes
Return a pointer and let JS access the WebAssembly memory to retrieve the values
Serialize to json and return the string

I'll use the 2nd approach because it's the fastest. In terms of performance we don't want to transfer a lot of data between JS and Wasm. A pointer is very small and because JS has access to the WebAssembly memory this will be very fast!

To return the pointer we have this method

    #[wasm_bindgen]
        pub fn get_points(&self) -> *const PointLocation {
            self.points.as_ptr()
    }

PointLocation has this shape

    #[wasm_bindgen]
    struct PointLocation {
        x: f64,
        y: f64,
    }

Generating the WebAssembly package #

With wasm-pack build --target web the npm compatible package will be generated in the pkg folder.
We can include it from our web application now.

I used the Vite Bundler, but this is compatible with most bundlers.

Using our wasm module from JS #

After generating the package I added it as a dependency in my web application.
This step is different for each bundler (vanilla JS is also supported).

Now in my web application I can access the exported Rust structs and methods

    import init, { App } from "rust-constraint-solver-wasm";

    const runWasm = async () => {
    //init will fetch our .wasm file
    const wasm = await init();
    //Let's create an instance of the exported App struct (defined in rust)
    const app = new App();

    //the main method that will run the solver
    //for demo purposes we are not passing any parameter. In real life 
    //we should pass the initial values (e.g the width of the window, positions, etc)
    //to get the updated values
    app.update_locations();
    
    //We didn't return the values from update_locations,
    //just updated the memory with the values of interest, 
    //now we need to access the wasm memory space and retrieve them.
    const points_ptr = app.get_points();
    const points = new Float64Array(wasm.memory.buffer, points_ptr, 4);
    console.log({ points });
};

When running the app you'll see in the log, the list of updated values.
Not very exciting but this opens the opportunity to solve much more interesting problems that can be expressed with linear constraints.

console output

What's next #

Now that we have a proof of concept, we could try creating layout systems for Canvas, WebGL. I see some potential for layout systems that offer a more natural way to arrange elements.

WebAssembly in the Browser (Basics)

2022-11-02T00:00:00Z

(As part of my WebAssembly explorations I'll be sharing some of my learnings as a mix of notes/tutorial/high level overview.
I won't detail every step, but I'll try to explain the concepts and the decisions at least at a high level.)

In this post I'll show you how to get started with WebAssembly in the browser using the Rust programming language to create the WebAssembly module.

With WebAssembly, we have a way to run code created in other languages inside the browser. (You can also use it in the server but I'll focus on the browser here)

The process (high level overview) #

Write the WebAssembly module in a supported language (Rust, Go, C#, AssemblyScript, etc)
Compile (instructions depend on the selected language) and generate the binary file with .wasm extension
Include the .wasm file in your web application, it must be published with your web application
Load the file in JavaScript and run the WebAssembly exported methods.

Let's go through each step.

Installing rust toolchain (optional) #

(If you don't want do do it you can skip this step and just download the pre-built package here https://github.com/hugozap/rust-format-message-example-library/releases/download/v1/pkg.zip)

If you want to generate the WebAssembly module from Rust you need to install the Rust toolchain from (https://rustup.rs/).

To install wasm-pack (a tool that will help us to generate the npm compatible package):

cargo install wasm-pack

Writing the WebAssembly module (optional) #

I'll use Rust for this example. I'll use the wasm-bindgen crate to generate the bindings between Rust and JavaScript.

The first step is to create a new Rust project with cargo new rust-simple-library --lib

Then we need to add the wasm-bindgen dependency to our Cargo.toml file

[dependencies]
wasm-bindgen = "0.2.83"

Now we can start writing our code. We'll create a simple library that returns an ascii message with the text we pass

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
fn format_message(t:&str)->String {

    let mut result = String::new();
    let mut max = 0;
    //find the longest line
    for line in t.lines() {
        if line.len() > max {
            max = line.len();
        }
    }
    //print the top line
    result.push_str(&"*".repeat(max+4));
    result.push_str("\n");
    //print the text
    for line in t.lines() {
        result.push_str("* ");
        result.push_str(line);
        //add spaces to the end of the line
        result.push_str(&" ".repeat(max-line.len()));
        result.push_str(" *\n");
    }
    //print the bottom line
    result.push_str(&"*".repeat(max+4));
    result.push_str("\n");
    return result;
}

Compiling the WebAssembly module (optional) #

Now we'll compile the code with wasm-pack build --target web

This will generate the pkg folder with the npm compatible package. We can include it from our web application now.

Including the wasm module in our web application #

We need the .wasm and js helper files to be published with our web application. Depending on the bundler we use, we'll have different ways to include it.

If you don't use a bundler you can compile the module with --target no_modules and include the .wasm file in your web site contents folder.

Common bundler wasm plugins #

For Webpack:
https://github.com/wasm-tool/wasm-pack-plugin

For Vite:
https://github.com/nshen/vite-plugin-wasm-pack/

Using our wasm module from JS #

I'll import the wasm module in my web application with import init, { printTextInsideRectangle } from "rust-simple-library"

This is possible because wasm-pack generated the bindings for us.

import init, { format_message } from "rust-simple-library";

const runWasm = async () => {
    //init will fetch our .wasm file
    const wasm = await init();
    //let's call the exported method
    const result = format_message("Hello World!");
    console.log(result);
}

runWasm();

Note: We need to wrap our code in an async function and call it. This is because we need to wait for the wasm module to be loaded and top level await is not supported yet.

If we run this code we'll see the following output in the console

****************
* Hello World! *
****************

What's going on under the hood? #

If you open the js bindings (ascii_simple_message.js) file you'll see glue code that will call the WebAssembly object to instantiate the module and call the exported methods.

This is how the .wasm file is loaded

async function init(input) {
    if (typeof input === 'undefined') {
        input = new URL('ascii_simple_message_bg.wasm', import.meta.url);
    }
    ...
}

It uses a simple fetch to load the .wasm file.

I recommend taking a look at the generated bindings to understand how it works and see the glue code generated by wasm-bindgen. It basically creates proxy objects for each exported method.

There are some helper methods to convert the arguments and return values to the correct types. This is required because only basic types can be passed/received to the WebAssembly module.

Conclusion #

This was a simple example to show how to get started with WebAssembly in the browser. There are many more things to explore like memory management, calling JavaScript from WebAssembly, serializing/deserializing objects, etc.

I'll cover some of these topics in future posts.

Running Rust code in the cloud with AWS Lambda

2024-02-14T00:00:00Z

Introduction #

Running Rust code in AWS lambda has many benefits, I personally enjoy working with Rust, the strict compiler and the cargo ecosystem. Having a quick way to create serverless functions with Rust seems like a great idea.

We'll go through the steps necessary to create a lambda using cloudformation syntax, the AWS CLI and preparing our Rust code to be deployed.

Required tools #

rustup: for adding the new compilation target (needed for Mac)
cargo lambda: Helps building rust packages that will target AWS Lambda runtime
AWS CLI: For deploying the cloudformation stack

Writing our Rust program #

The code we'll use is taken from the examples of the lambda_http repository. It's a very simple function that returns a string, it's enough to test if things work and a useful starter template:

/// Extracted from  https://github.com/awslabs/aws-lambda-rust-runtime/tree/main/examples

use lambda_http::{run, service_fn, Body, Error, Request, Response};
use tracing_subscriber;
use tracing;
async fn function_handler(_event: Request) -> Result<Response<Body>, Error> {
    // Extract some useful information from the request

    // Return something that implements IntoResponse.
    // It will be serialized to the right response event automatically by the runtime
    let resp = Response::builder()
        .status(200)
        .header("content-type", "text/html")
        .body("Hello AWS Lambda HTTP request".into())
        .map_err(Box::new)?;
    Ok(resp)
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    // required to enable CloudWatch error logging by the runtime
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        // disable printing the name of the module in every log line.
        .with_target(false)
        // disabling time is handy because CloudWatch will add the ingestion time.
        .without_time()
        .init();

    run(service_fn(function_handler)).await
}

The idea is simple, you wrap your function handler in a service_fn and it's itself wrapped in a run function. Tokyo is used to provide the async capabilities.

lambda_runtime vs lambda_http #

When I tried the first time I used an example that used lambda_runtime and got some issues because lambda_runtime does not understand AWS Api Gateway context. I found out that lambda_http is the right choice for this case as it's a higher level library that abstracts the API Gateway request/response objects.

Compiling the Rust code #

I'm using a Mac, the first time I tried to deploy the package I got an error due to executable incompatibilities. I learned I had to target a linux platform so it's compatible with the AWS Lambda environment.

Installing the linux target with rustup:

rustup target add x86_64-unknown-linux-musl

And now building the package for the new target using cargo lambda:

cargo lambda build --target=x86_64-unknown-linux-musl --release

Creating the lambda zip package. #

We now have to create a zip that contains the compiled artifacts created in the compilation step.

The cargo lambda tool creates a file called bootstrapin the target/lambda/your-project-name directory and this is the only file that we need to zip.

Run the following command to create the zip (from the directory that contains the bootstrap file):

zip -r lambda-package.zip

Creating the S3 bucket to store the lambda package: #

Let's create an encrypted S3 bucket to store our lambda zip package.

# Replace `rust-lambda-code-test` with your bucket name!
aws s3api create-bucket --bucket rust-lambda-code-test --region us-east-1
aws s3api put-bucket-encryption --bucket rust-lambda-code-test --server-side-encryption-configuration '{"Rules":[{"ApplyServerSideEncryptionByDefault":{"SSEAlgorithm":"AES256"}}]}'

The Cloudformation template #

I used this cloudformation template to create the Lambda in AWS, make sure to adjust the path of the .zip package we created before:

The parameters defined by this template are:

BucketName: The name of the S3 bucket where the Lambda deployment package is located
PathToLambdaZip: Local path to the zip package created before

** Note: I put the cloudformation template in a file called in the path: cloud-formation/rust-lambda.yaml inside my Rust project, this path will be needed create the stack later **

AWSTemplateFormatVersion: '2010-09-09'
Parameters:
  BucketName:
    Type: String
    Description: The name of the S3 bucket where the Lambda deployment package is located
    Default: your-bucket-name
  PathToLambdaZip:
    Type: String
    Description: The path to the Lambda deployment package in the S3 bucket
    Default: path/to/lambda.zip
Resources:
  RustLambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Runtime: provided.al2
      Code:
        S3Bucket: !Ref BucketName
        S3Key: !Ref PathToLambdaZip
      MemorySize: 128
      Timeout: 15

  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: 'sts:AssumeRole'
      Policies:
        - PolicyName: LambdaExecutionPolicy
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action: 'logs:*'
                Resource: 'arn:aws:logs:*:*:*'

  MyApi:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: RustServiceAPI

  Resource:
    Type: AWS::ApiGateway::Resource
    DependsOn: MyApi
    Properties:
      RestApiId: !Ref MyApi
      ParentId: !GetAtt 'MyApi.RootResourceId'
      PathPart: rustservice

  Method:
    Type: AWS::ApiGateway::Method
    DependsOn: Resource
    Properties:
      RestApiId: !Ref MyApi
      ResourceId: !Ref Resource
      HttpMethod: POST
      AuthorizationType: NONE
      Integration:
        Type: AWS_PROXY
        IntegrationHttpMethod: POST
        Uri: !Sub 'arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${RustLambdaFunction.Arn}/invocations'
      MethodResponses: []

  LambdaInvokePermission:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !Ref RustLambdaFunction
      Action: lambda:InvokeFunction
      Principal: apigateway.amazonaws.com
      SourceArn: !Sub 'arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${MyApi}/*/*/*'
  ApiDeployment:
    Type: AWS::ApiGateway::Deployment
    DependsOn: Method
    Properties:
      RestApiId: !Ref MyApi
      StageName: Dev
Outputs:
  ApiEndpoint:
    Description: "API Gateway endpoint URL for the Rust service"
    Value: !Sub "https://${MyApi}.execute-api.${AWS::Region}.amazonaws.com/Dev/rustservice"

Deploying the Cloudformation stack #

To deploy de stack, run the following command providing the required parameters for bucket name and zip package location. The AWS CLI tool will start the process of deploying and you can see the result on the AWS Console:

aws cloudformation create-stack \
  --stack-name RustLambdaServiceTestStack \
  --template-body file://cloud-formation/rust-lambda.yaml \
  --parameters ParameterKey=BucketName,ParameterValue=rust-lambda-code-test \
               ParameterKey=PathToLambdaZip,ParameterValue=lambda-package.zip \
  --capabilities CAPABILITY_IAM CAPABILITY_NAMED_IAM

Updating our Rust code #

If you change your code, you'll need to build and create the zip file again. Then run the following command to update the stack:

aws cloudformation update-stack \
  --stack-name RustLambdaServiceTestStack \
  --template-body file://cloud-formation/rust-lambda.yaml \
  --parameters ParameterKey=BucketName,ParameterValue=rust-lambda-code-test \
               ParameterKey=PathToLambdaZip,ParameterValue=lambda-package-v2.zip \
  --capabilities CAPABILITY_IAM CAPABILITY_NAMED_IAM

Obtaining the API URL #

Go to the AWS Console -> Cloud Formation and look for the stack you created. Click on the Outputs tab and you'll find the URL of the API endpoint you can use.

Testing the Lambda #

To test that our lambda works send an HTTP request using curl or any other tool:

curl -X POST -H "Content-Type: application/json" https://<generated-id>.execute-api.us-east-1.amazonaws.com/Dev/rustservice

Result:

Hello AWS Lambda HTTP request

Conclusion #

Having a way to quickly deploy Rust code as serverless functions is very useful. Not being dependent on a runtime makes things simpler in terms of compiling/updating and deployment of our code.

Using NATS(JetStream) as Gorilla session provider in Go

2024-09-28T00:00:00Z

For a fun side project I'm using NATS, specifically JetStream, its key value storage engine.

I wanted to handle sessions using NATS with the gorilla Golang package, but didn't find a provider.

Turns out building one for it was not hard thanks to the easy to implement gorilla interface for session management.

Usage:

import "github.com/hugozap/natsstore"


store, err := natsstore.NewStore(js, "myapp", []byte("secret-key"))

You can get it from here here: https://github.com/hugozap/natsstore

Diagram Codes Desktop is free now

2025-10-30T00:00:00Z

Download here:

Link to documentation:
https://hugozap.github.io/diagram-codes-desktop-app/#/

Some time ago I created a software for creating Diagrams from simple text syntax called Diagram.Codes. Even though I stopped working on the project, it's still a great utility for creating diagrams and it's used by users in different industries and now you can use it for free.

I love local tools you can install and use even with no connectivity and I wanted to create an application for quickly creating diagrams and export them.

Working on Diagramm Codes I learnt a lot, from designing custom Domain Specific Languages (DSL).

I haven't published the code yet but I may do it in the future when I have some time for cleaning it.

I'm currently working on an improved layout engine created in Rust as a hobby project and hope to release some derived tools in the future.

Hope you find it useful.

mcp-inspector, a TUI to debug MCP traffic

2026-07-31T00:00:00Z

Repo: https://github.com/hugozap/mcp-inspector

If you've built or debugged an MCP (Model Context Protocol) server, you know the usual routine: reading raw JSON from logs or sprinkling print statements to see what's actually being sent back and forth.

mcp-inspector is a small terminal tool I built to fix that. It sits between an MCP client and server as a proxy, captures every message, and lets you browse them live in a navigable TUI — no configuration needed.

It runs headlessly as the actual server command (for example inside Claude Desktop's config), broadcasting traffic over a Unix socket, while mcp-inspector view connects from any terminal to show requests, responses, notifications and errors in real time. You can filter by message type, search live, and export a session to NDJSON.

It's written in Rust and available on crates.io:

cargo install mcp-inspector

SSE/HTTP proxy mode and pre-built binaries are on the roadmap.