DEV Community: Jake Roggenbuck

⚡ Share the Rust projects that you're excited about!

Jake Roggenbuck — Sat, 12 Jul 2025 00:16:07 +0000

Jake Roggenbuck

Jul 12 '25

What Rust projects are you most excited about?

#rust #programming #beginners #tutorial

Comments

1 min read

What Rust projects are you most excited about?

Jake Roggenbuck — Sat, 12 Jul 2025 00:14:38 +0000

What I'm excited about

I'm most excited about SWC, the TypeScript and JavaScript compiler written in Rust.

I am also looking forward to uv, the really fast Python package manager written in Rust. I think Rust tooling for Python has great potential. Astral is also making a project called Ruff, which is a formatter and I'm also very excited about that.

Let's hear from you!

What projects are you most looking forward to seeing in the future?

View more projects on https://jr0.org

🔥 Using Regex validation in Express with the Regolith Library in JavaScript

Jake Roggenbuck — Sat, 12 Jul 2025 00:05:23 +0000

Using Regex with Express

Jake Roggenbuck ・ Jul 12

#express #javascript #typescript #backend

⭐ How to use Regex validation in Express with the new Regolith Library

Jake Roggenbuck — Sat, 12 Jul 2025 00:04:05 +0000

Jake Roggenbuck

Jul 12 '25

Using Regex with Express

#express #javascript #typescript #backend

Comments

5 min read

Using Regex with Express

Jake Roggenbuck — Sat, 12 Jul 2025 00:03:05 +0000

This is a brief introduction to using Regex validation in an Express backend. We will be using the new Regex library called Regolith that prevents Regular Expression Denial of Service Attacks when creating Regex patterns. More information about this library is shared below or on the GitHub page.

Project Setup

Start by creating a project in your terminal:

mkdir express-example

Navigate in to the newly created project:

cd express-example

Initialize the JavaScript Project:

npm init

Fill in the details for the new project. You can also just press enter for every field for the default (which is fine).

Install Express and Regolith:

npm i express @regolithjs/regolith

Edit the contents of package.json and change type: "commonjs" to type: "module" to allow us to use the module import syntax.

It should end up looking something like this:

{
  "name": "express-example",
  "version": "1.0.0",
  "description": "",
  "license": "ISC",
  "author": "",
  "type": "module",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "dependencies": {
    "@regolithjs/regolith": "^0.1.4",
    "express": "^5.1.0"
  }
}

Writing the code

Create a file that will contain all of our code called index.js in your favorite editor.

Open the file and then add the following code:

import express from "express";

console.log(express);

Now when we run the code with node index.js, we should see the following:

[Function: createApplication] {
  application: {
    init: [Function: init],
    defaultConfiguration: [Function: defaultConfiguration],

  // ...

  text: [Function: text],
  urlencoded: [Function: urlencoded]
}

This shows us that Express was imported and installed correctly.

We can now add some basic Express code to our index.js:

import express from "express";
import { Regolith } from "@regolithjs/regolith";

const app = express();
const port = 3000;

console.log("Show Regolith is installed correctly:", Regolith);

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
});

Run the code with node index.js and we should see the server start up:

Show Regolith is installed correctly. [Function: Regolith]
Example app listening on port 3000

This also shows us that Regolith is installed correctly.

Now we can create Regex patterns with Regolith that check if a provided input matches either the int pattern or the float pattern. Imagine we wanted to create a basic server that helps us validate different types of numbers.

import express from "express";
import { Regolith } from "@regolithjs/regolith";

const app = express();
const port = 3000;

// Create Regolith Regex patterns
const intPattern = new Regolith("^\\d+$");
const floatPattern = new Regolith("^\\d*\\.\\d+$");

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
});

Now we can test to see if our new Regex patterns work:

import express from "express";
import { Regolith } from "@regolithjs/regolith";

const app = express();
const port = 3000;

// Create Regolith Regex patterns
const intPattern = new Regolith("^\\d+$");
const floatPattern = new Regolith("^\\d*\\.\\d+$");

console.log("Should be true:", intPattern.test("10"));
console.log("Should be true:", floatPattern.test("10.0"));

console.log("Should be false:", intPattern.test("hello"));
console.log("Should be false:", floatPattern.test("world"));

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
});

We added some console.log statements that test different inputs.

When we run this with node index.js, we should see true, true, false, false:

Should be true: true
Should be true: true
Should be false: false
Should be false: false
Example app listening on port 3000

We can trade the logging code with a route, that will allow us to call our backend:

app.get("/check", (req, res) => {
    // Get the input value that we will test
    const value = req.query.value;

    // Run the test with Regolith pattern
    const isInt = intPattern.test(value);
    const isFloat = floatPattern.test(value);

    // Return out test output
    res.json({isInt, isFloat});
});

This will respond when we call the /check route when we give a value like so /check?value=10. When we validate that this works, we can run node index.js and then see the URL (http://localhost:3000/check?value=10) in our browser.

This is what the browser page should look like:

The full code after that should look like this:

import express from "express";
import { Regolith } from "@regolithjs/regolith";

const app = express();
const port = 3000;

// Create Regolith Regex patterns
const intPattern = new Regolith("^\\d+$");
const floatPattern = new Regolith("^\\d*\\.\\d+$");

app.get("/check", (req, res) => {
    // Get the input value that we will test
    const value = req.query.value;

    // Run the test with Regolith pattern
    const isInt = intPattern.test(value);
    const isFloat = floatPattern.test(value);

    // Return out test output
    res.json({isInt, isFloat});
});

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
});

We can add input validation to check that we provided the value URL parameter:

// Make sure that we provide a `value` in the request
if (!value) {
    return res.status(400).send("Please provide a value query parameter");
}

We can also include the input value in the final output:

res.json({
    value,
    isInt,
    isFloat,
});

The final code should be:

import express from "express";
import { Regolith } from "@regolithjs/regolith";

const app = express();
const port = 3000;

// Create Regolith Regex patterns
const intPattern = new Regolith("^\\d+$");
const floatPattern = new Regolith("^\\d*\\.\\d+$");

app.get("/check", (req, res) => {
    // Get the input value that we will test
    const value = req.query.value;

    // Make sure that we provide a `value` in the request
    if (!value) {
        return res.status(400).send("Please provide a value query parameter");
    }

    // Run the test with Regolith pattern
    const isInt = intPattern.test(value);
    const isFloat = floatPattern.test(value);

    // Return out test output
    res.json({
        value,
        isInt,
        isFloat,
    });
});

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
});

We can even test this using the curl command if you have that installed. If not, browser works fine as well.

Check with a float value

curl http://localhost:3000/check?value=10.2

Output from float test

{"value":"10.2","isInt":false,"isFloat":true}

Check with an int value

curl http://localhost:3000/check?value=10

Output from int test

{"value":"10","isInt":true,"isFloat":false}

What are ReDoS attacks?

Regular Expression Denial of Service (ReDoS) attacks occur when vulnerable Regex patterns are executed with specifically constructed inputs that result in an inefficient execution. This can be exploited to cause services to become unavailable because the services are stuck trying to compute the inefficient Regex.

How does Regolith prevent ReDoS attacks?

Regolith prevents ReDoS attacks by disallowing features that make Regex vulnerable to ReDoS attacks. Two of these features are backreferences and look-around, which aren't available in Regolith. When they features are invoked in other Regex libraries, they can take exponentially long to execute, crashing your server and causing a denial of service. We want to prevent this, so we use Regolith, which has a linear worst case time.

Feedback

If you have any feedback or questions, please add a comment here or ask in the Regolith discussion form.

⭐ If you found this article valuable, consider supporting us by giving the Regolith GitHub a star.

⚡️ Say goodbye to ReDoS. Regolith delivers blazing-fast, Rust-backed regex for JavaScript & TypeScript.

Jake Roggenbuck — Thu, 03 Jul 2025 02:40:08 +0000

Preventing ReDoS Attacks with Regolith

Jake Roggenbuck ・ Jul 3

#programming #javascript #typescript #news

🔥 Stop ReDoS in its tracks and try Regolith, the Rust-powered regex engine for JavaScript & TypeScript.

Jake Roggenbuck — Thu, 03 Jul 2025 02:37:37 +0000

Jake Roggenbuck

Jul 3 '25

Preventing ReDoS Attacks with Regolith

#news #programming #javascript #typescript

Comments 1

3 min read

Preventing ReDoS Attacks with Regolith

Jake Roggenbuck — Thu, 03 Jul 2025 01:15:29 +0000

Description

A server-side TypeScript and JavaScript library immune to Regular Expression Denial of Service (ReDoS) attacks by using Rust and linear Regex under the hood. Regolith has a linear worst case time complexity, compared to the default RegExp found in TypeScript and JavaScript, which has an exponential worst case.

Install Regolith with NPM

npm i @regolithjs/regolith

Try it out

import { Regolith } from '@regolithjs/regolith';

const pattern = new Regolith("^\\d+$");

pattern.test("12345");  // true
pattern.test("Hello");  // false

What are ReDoS attacks?

Linear vs Exponential Regex Libraries

This table shows popular languages and if their Regex library has a linear worst case or an exponential worst case. It also includes experimental results for how long execution took for a vulnerable Regex pattern that can be attacked with ReDoS and an input of size 30.

Drop-in Replacement

Regolith attempts to be a drop-in replacement for RegExp and requires minimal (to no) changes to be used instead. The goal of Regolith is to allow developers to easily build software that is immune to ReDoS attacks.

Impact

These vulnerabilities happen relatively often in popular libraries. It's no one's fault specifically, it just comes down to the fact that the language allows for these things to happen.

A recent example of a ReDoS vulnerability is CVE-2025-5889 from brace-expansion. Again, this isn't any fault of that project, it's simply an issue with the language allowing this to happen. Measures can be put into place to reduce the risk of this, but it's hard to spot and test for these issues.

The brace-expansion project is used by 42.5 million other projects on GitHub. Meaning if everyone were to patch their software (which the hopefully will), that would be 42.5 million pull requests, roughly 42.5 million build minutes, and probably more than 42 million engineering minutes as well. All of that for a single vulnerability, and that's just a lower bound of effort spent on this if everyone were to keep their software patched.

Other versions of brace-expansion had these patches backported to them, needing updates for versions 1, 2, 3, and the current version 4.

Having a library or project that is immune to these vulnerabilities would save this effort for each project that adopted it, and would save the whole package ecosystem that effort if widely adopted. Adoption of libraries is difficult, especially when they aren't very flashy, but helping library maintainers and engineers not worry about ReDoS for one library, one project at a time, is our goal.

Trade-off

The Rust Regex library purposefully excludes features that make Regex engines particularly vulnerable to ReDoS attacks. Those features are backreferences and look-around. Excluding those features allow Regex to guarantee linear time execution.

Since Regolith uses Rust bindings to implement the Rust Regex library to achieve linear time worst case, this means that backreferences and look-around aren't available in Regolith either.

This trade-off has proven to be worth it for the Rust community of libraries and projects.

Results

Since ReDoS vulnerabilities are hard to spot, there are rather frequent CVEs that get submitted. Having a Regex library that has a linear worst case time would completely prevent all of these potential issues for downstream projects.

Closing

View more info on GitHub

Git Revert? Restore? Reset?

Jake Roggenbuck — Mon, 24 Jun 2024 19:43:29 +0000

Git revert, restore, reset ???
Here is what they all do.

Git revert

Makes a commit that is the opposite changes of a specified commit.

Changes from commit abc

+ My name is Jake

git revert abc

Creates a commit that removes the line added in commit abc.

- My name is Jake

Git reset

You can unstage changes with git reset <filename>.

Git reset can change the commit history to remove commits when using --hard so be careful with this one!

Git restore

Git restore - restore a given file in your working tree

Want to undo an auto format for a given file?

Run git restore <filename>

View more projects on https://jr0.org

5 BEST Git Commands

Jake Roggenbuck — Sun, 05 May 2024 20:44:53 +0000

These are the top 5 most useful git commands that I use almost every day. Out of the 30+ git command aliases I have, these are the for sure the best 5! Please let me know in the comments which ones you like the best!

If you have a favorite command of your own, please share in the comments! I'll highlight my favorite ones!

1. Git List (GLS)

View a super short summary of the most recent commits. Instead of filling the page with just a few commits, view each commit in a single line.

git log --pretty=oneline --abbrev-commit

I have this aliased to gls with

alias gls='git log --pretty=oneline --abbrev-commit'

2. Push Origin (PUSHO)

Push to the current default branch. This one is simple, but I use this one the most.

git push origin $(git symbolic-ref --short HEAD)

I have this aliases to pusho in my .bashrc with

alias pusho='git push origin $(git symbolic-ref --short HEAD)'

3. Git logg (LOGG)

View an ascii art history of all of the branches.

git log --graph --decorate --all

I have this aliased to logg with

alias logg='git log --graph --decorate --all'

4. Git Diff Precise (GDP)

Have you ever been looking at a git diff and it just tells you the whole line is different? Well, this command tells you exactly what characters have changed. Extremely helpful for catching issues in review or remembering exactly what you changed in a large line.

Before

After

This is a simple example and it's easy to see what has changed, but if you had a really complicated line with a few different changes in different places, it can be hard to catch. Say an SQL command or similar.

Here is how to do it!

git diff --word-diff=color --word-diff-regex=.

I have this aliased to gdp with

alias gdp='git diff --word-diff=color --word-diff-regex=.'

5. The MOST useful of all (lookz)

Have you ever tried looking through a whole git history to try to find where you added or removed something? Has a line gone missing or a type changed that has caused an issue in production that you need to fix ASAP! Looking through each commit for a single line may take hours with a big repository. This allows you to search through every commit and use FZF to do it.

This does require you to have fzf installed, but I recommend having that anyway. It's super useful for this type of thing.

git remote && git log --pretty=oneline --abbrev-commit \
| awk '{print $1}' \
| xargs -I {} git show {} | fzf

I have this aliased to lookz with

alias lookz='git remote && git log --pretty=oneline --abbrev-commit | awk '"'"'{print $1}'"'"' | xargs -I {} git show {} | fzf'

Note the single quotes having to be escaped with '"'"' in the bash alias version but not the one directly for the shell.

I need help making this command more useful. It lets you find a specific name of something that can then be used to search, but once it's selected, you can't find the commit. If anyone knows how to do this, please leave a comment!

View more projects on https://jr0.org

Favorite websites for Style!

Jake Roggenbuck — Thu, 02 May 2024 06:05:22 +0000

By far, my favorite is https://coolors.co/ for finding color palettes.

For picking individual colors, it would be https://htmlcolorcodes.com/. It has a great default palette and great tools like the color picker that shows Triadic, Complementary, and other combinations of colors.

That's all, Thanks! If you have any other good resources, let me know in the comments!

Cover Image Credit: coolors.co

What's your favorite Go web framework?

Jake Roggenbuck — Wed, 01 May 2024 20:02:31 +0000

I've used Gin-Gonic and Fiber a lot. Both have been great! I'm interested in knowing what other developers like to use.

Please feel free to share what you use!

Cheers,
Jake

View more projects on https://jr0.org