DEV Community: vicmdv

A cautionary tale on project-based-development

vicmdv — Sat, 25 Nov 2023 19:41:17 +0000

Hello! I'm Víctor (aka Brian3647), the author of snowboard (a http request parser & response generator) and a bunch of other things I might not want to talk about.

"Learning a new programming language" isn't quite what you might want to do

We have all, at least once, stumbled upon those 12-hour YouTube videos on how to learn a programming language like rust, javascript or python. Don't get me wrong, those are good, but they're definitely not for everyone. And by that, I mean only a small fraction of people actually learn to code. But first, we have to define that:

What is coding?

Wikipedia might say something, and so will the dictionary, but I think coding might be as subjective as being good in a sport - sure, everyone can understand that a specific sequence of characters will print "hello, world!" to the terminal, but not many will even think about what are they actually doing.

In my opinion, a good coder is not someone who knows data structures, file systems, algorithms or creates beautiful websites, but rather one that has a mind able to see a problem, relax for a bit, read something and find a solution for it.

Because, face it, memorization isn't learning.

And neither is listening through 10 hours on how to make the compiler not cry and be able to copy code faster.

Project-based development is scary

Well, why not simply start with projects? Sounds good, doesn't it? Well, no.

I mainly divide project-based-dev into 2 categories:

Big tutorials
Documentation surfing

The first one, big tutorials, are usually courses (often paid*) that teach you how to do a specific thing, usually something like a discord bot, a web application using react (use htmx instead) or something in the lines of an AI bot able to solve all your problems. Those are fun projects, yes, and once you start with them you feel unstoppable since everything works after a quick syntax error question in any forum, but trust me, they rarely help you.

They mostly make you learn a 101 on how to get muted in any discord programming server, and if you manage to learn something, it will mostly be either too broad or too specific to actually help.

The dark corner of documentation surfing

Thing is, even if you don't want to, you're going to have to learn how to search and read documentation earlier or later. And it can be ok (if it isn't a npm package). So being able to search information quickly and effectively is something that needs to be taught as soon as possible. You'll eventually find out that a good google search usually removes the wait time of asking to other people, and that most programming languages are at least a little bit readable.

Do your own thing

It's ok, we're all out of good multimillionaire start-up ideas, but that definitely does not mean you should do another to-do app using 5GB worth of libraries. In fact, I've found out that most of the times, you're using a part of the library so small you might as well just write that part yourself, removing everything that you don't really use. This is extremely common when using a library that is basically a wrapper for another, where you're only using a tiny part of a tiny part of something.

And when you have to go out of your way to do something that everyone is doing using another one's massive codebase, is where I found out you learn most of what you actually need.

An example of this might be building static websites with something completely overkill for what you actually need instead of doing something as simple as a template replacement (eg. my own encoped)

Conclusion

After all, this is jut my opinion, and not only can but WILL be different for different people. That being said, if you do want to start building your own things, there's a bunch of things you can do.

Do not be afraid to reinvent the wheel. Take your favorite programming language, build a JSON parser, call it super-fast, center the title in README.md and patiently wait for the big total amount of 6 github stars in your project.

Good luck!

ps: Q: does anyone know where to show people your work without getting destroyed? - A: nope

Snowboard v1.0.0 is here! 🏂🦀

vicmdv — Wed, 22 Nov 2023 17:52:17 +0000

I first talked online about snowboard here, and now, only 27 days after, snowboard 1.0.0 is available & production-ready!

What is snowboard?

Snowboard is a tool for creating extremely fast web servers in rust. It comes with its own request & url parser and a bunch of optional features like JSON/serde support, TLS security, WebSockets & asynchronous handlers.

Quickstart

You can install snowboard by adding it to your Cargo.toml:

[dependencies]
snowboard = "1"

and use it without any need of macro derives:

use snowboard::{headers, response, Method, Server};

fn main() -> snowboard::Result {
    let data = "Hello, world!";

    let server = Server::new("localhost:8080")?;

    println!("Listening on {}", server.pretty_addr()?);

    server.run(move |mut req| {
        if req.method == Method::DELETE {
            return response!(method_not_allowed, "Caught you trying to delete!");
        }

        req.set_header("X-Server", "Snowboard");

        println!("{req:#?}");

        response!(ok, data, headers! { "X-Hello" => "World!" })
    })
}

More info (& how to use async, tls, and other features) can be found in the readme. Happy coding!

repo:

Brian3647 / snowboard

fast, simple & reliable http rust servers 🏂

Snowboard 🏂

An extremely simple (& blazingly fast) library for HTTP & HTTPS servers in Rust

Request a feature/Report a bug

Table of Contents

Snowboard 🏂

Quick start

To get started with Snowboard, simply add it to your Cargo.toml file:

[dependencies]
snowboard = "*"

Then, create a new Rust file with the following code:

use snowboard::{headers, response, Method, Result, Server};
fn main() -> Result {
    let data = "Hello, world!";

    let server = Server::new("localhost:8080")?;

    println!("Listening on {}", server.pretty_addr()?);

    server.run(move |mut req| {
        if req.method == Method::DELETE {
            return response!

…

View on GitHub

🦀⚡ Building extremely fast APIs with Rust & snowboard: Step-by-Step

vicmdv — Thu, 26 Oct 2023 15:02:39 +0000

Today we'll be writing a working web API using rust and snowboard, an extremely simple HTTP library.

Setting up the server
Creating the routes
Wrapping up

Prerequisites

You'll need to have rust installed for this project.

1. Setting up the server

First off, we'll create the project (that will be named "faster") and install snowboard:

$ cargo new faster
$ cd faster
$ cargo add snowboard@0.4.1

Then, we will add the following code to src/main.rs:

use snowboard::{response, Server};

fn main() {
    Server::new("localhost:3000").run(|req| {
        println!("Request: {:?}", req);

        response!(ok, "Hello, world!")
    });
}

and run it using cargo run. And that's it! You got yourself a working server on localhost:3000. Now, to the API functionality

2. Creating the routes

Instead of using that closure, we'll be writing our app router in a new function called router and adding some routes:

use snowboard::{response, Request, Response, Server};

fn router(req: Request) -> Response {
    let path = req.parse_url();

    match path.at(0) {
        Some("hello") => match path.at(1) {
            Some(name) => response!(ok, format!("Hello, {}!", name)),
            None => response!(ok, "Hello, World!"),
        },
        None => response!(
            ok,
            "Send a request to /hello to get a greeting!"
        ),
        _ => response!(not_found, "👀"),
    }
}

fn main() {
    Server::new("localhost:3000").run(router);
}

In this code, we're doing a lot of things:

We're checking for the first part of the path (url/this). If the request is just /, that'll be None where we return an ok response (point 5).
If it matches and it's "/hello" we check for the second part of the path (url/hello/this). If it exists, we get it and say hello to them. If it doesn't, we just return "Hello, world!".

And it works perfectly! You can check it out for yourself on your terminal using curl:

$ curl localhost:3000/
Send a request to /hello to get a greeting!
$ curl localhost:3000/hello
Hello, World!
$ curl localhost:3000/hello/Joe
Hello, Joe!
$ curl localhost:3000/thisroutedoesntexist
👀

3. Wrapping up

That's it for today! You got yourself an extremely fast & simple API written in Rust. You can check out snowboard here on contact me in discord @ Brian3647.

If needed, snowboard also supports async/await routes, so feel free to expand your API however you want to.