DEV Community: sai umesh

Slide, a Go web framework for developers coming from Express.

sai umesh — Sun, 09 Aug 2020 14:32:02 +0000

Slide is one of the fastest frameworks, built on top of fasthttp. People coming from express will feel at home.

Motivation

While playing around with the Go’s net/http, one thing that we missed most was the lack of middleware support and the problems it solves. After a little reading, we decided to write our own web framework which would solve the issues like middleware support with next, handle a wide range of files, Upload, Download, etc.

🚀 Example

package main

import (
    "log"
    "github.com/go-slide/slide"
    "github.com/go-playground/validator/v10"
)

func main() {
    validate := validator.New()
    config := slide.Config{
        Validator: validate,
    }
    app := slide.InitServer(&config)
    app.Get("/", func(ctx *slide.Ctx) error {
        return ctx.Send(http.StatusOK, "Hello, World")
    })
    log.Fatal(app.Listen("localhost:4321"))
}

Features

Slide supports Middleware with Next function

Express

var express = require('express')
var app = express()

app.use(function (req, res, next) {
  console.log('Time:', Date.now())
  next()
})

Slide

app := slide.InitServer(&config)

## Application level
// you can multiple middlewares also
app.Use(func(ctx *slide.Ctx) error {
    fmt.Println("this will run for all URL(s)")
    return ctx.Next()
})

Nested (Grouped) Routes

Express

var express = require('express')
var router = express.Router()
var auth = require('./auth')

router.use('/auth', auth)

// auth.js
var express = require('express')
var router = express.Router()

// GET /auth/login
router.get('/login', function (req, res, next) {
  res.send('this is the index auth/login')
});

module.exports = router

Slide

auth := app.Group("/auth")
auth.Use(func(ctx *slide.Ctx) error {
    fmt.Println("this will run for all /auth URL(s)")
    return ctx.Next()
})
auth.Get("/login", func(ctx *slide.Ctx) error {
    return ctx.Send(http.StatusOK, "Hello, World")
})

Files

Slide supports wide range of helpers for file

// serve dir
app.ServerDir("/static", "static")

// single file
app.ServeFile("/js", "static/login.js")

// Downloading file
app.Get("/download", func(ctx *slide.Ctx) error {
    return ctx.SendAttachment("static/login.js", "login.js")
})

// uploading file
app.Post("/upload", func(ctx *slide.Ctx) error {
    return ctx.UploadFile("static/login.js", "login.js")
})

// serve single from route
app.Get("/servefile", func(ctx *slide.Ctx) error {
   return ctx.ServeFile("static/index.html")
})

We would love to hear feedback from you. Thank you for reading.

Rust Ownership and Borrowing

sai umesh — Thu, 18 Jul 2019 13:26:54 +0000

Before we talk about Rust Ownership and Borrowing, I would like you to know that techempower has released round 18 results last week and Rust has clearly dominated in 4 of 5 categories, which shows how powerful Rust has become over the years.

Rust is a very powerful programming language but, learning Rust is not easy. it has a steep learning curve. The first thing you would find difficult to learn in Rust is probably going to be Ownership and Borrowing. Today we will try to learn basics of it.

This article is aimed at learning basics of it so, use this code in production with caution.

Rust neither has manual memory management nor garbage collector. Then the next obvious question would be, how does Rust manage memory 💭💭. Here comes Rust's most unique point, Ownership and Borrowing. let's see how does it work with some examples.

before we see any black and blue text, we need know about two types of variables:

Static allocated types ex: int
Heap Allocated types ex: array(Vector in Rust)

For any statically allocated types, Rust Ownership and Borrowing doesn't apply but for heap allocation it does apply. let's checkout some examples.


fn do_something(input: i32) -> i32 {
    input * 2
}


fn main() {
    let number: i32 = 1;
    let result = do_something(number);
    println!("result is {} for number {}", result, number)
}

run it on playground

if you run above program you would get following output, as expected.

result is 2 for number 1

now let's replace i32 (statically allocated) with String (Heap allocation) in above example.

fn do_something(input: String) -> String {
    // do something with string
    input
}


fn main() {
    let name: String = String::from("Hello!!");
    let result = do_something(name);
    println!("result is {} for string {}", result, name)
}

run it on playground

once you run above program you will encounter first O & B problem as follows.

--> src\main.rs:11:52
   |
9  |     let name: String = String::from("Hello!!");
   |         ---- move occurs because `name` has type `std::string::String`, which does not implement the `Copy` trait
10 |     let result = do_something(name);
   |                               ---- value moved here
11 |     println!("result is {} for string {}", result, name)
   |                                                    ^^^^ value borrowed here after move

Any heap allocated variable will have it's scope, and generally the scope is of lifetime of it's function(ownsership). but, if you pass any heap variable to another function, not only the variable but also it's scope will be passed to that function(ownsership) along with it's lifetime. this means, main() will not have access to name of type String once it's passed down to do_something(). once do_something() is done with it's execution, input variable of type String memory will be dropped. This is how Rust maintains memory management without managing manually.

Now, To solve above problem, we will send reference of the string but not actual variable.

fn do_something(input: &String) -> String {
    // do something with string
    input.to_string()
}


fn main() {
    let name: String = String::from("Hello!!");
    let result = do_something(&name);
    println!("result is {} for string {}", result, name)
}

run it on playground

if you run above program you would get following output.

result is Hello!! for name Hello!!

any variable in rust is immutable unless say otherwise. now let's try to mutate input and let's see what happens.


fn do_something(input: &String) {
    input.push_str("world!!")
}


fn main() {
    let name: String = String::from("Hello!!");
    do_something(&name);
    println!("result is {} for name", name)
}

run on playground

if you run above program you would get following output.

error[E0596]: cannot borrow `*input` as mutable, as it is behind a `&` reference
 --> src\main.rs:3:5
  |
2 | fn do_something(input: &String) {
  |                        ------- help: consider changing this to be a mutable reference: `&mut std::string::String`
3 |     input.push_str("World!!")
  |     ^^^^^ `input` is a `&` reference, so the data it refers to cannot be borrowed as mutable

since borrowed variable not mutable, we cannot mutate it. to solve the problem we need to make both original and passed variable mut mutable.

fn do_something(input: &mut String) {
    input.push_str(" World!!")
}


fn main() {
    let mut name: String = String::from("Hello!!");
    do_something(&mut name);
    println!("result is {} for name", name)
}

run it on playground

if you run above program you would get following output.

result is Hello!! World!! for name

I hope you enjoyed this article. If you have any doubt or help, you can contact me on twitter.

In next article we will talk about, how to create sharable variables between the threads.

Thanks for reading. Have a Good day!

Error Handling in Rust programming language

sai umesh — Sat, 27 Apr 2019 17:54:16 +0000

If you are following stack overflow developer survey, you might have seen Rust as most loved programming language 2 years in a row. Rust is probably most fascinating programming language I’ve seen, and I completely agree with survey.

Having said that, Learning Rust is not easy, learning curve is very high, and If you are coming from languages like JavaScript like me, it will be very challenging journey but, this tough road is worth it.

If you are very new to learning Rust, I strongly suggest starting with their docs, Rust has one of the best documentations available.

Today we will be looking at error handling in rust.

If you are coming from languages like JavaScript, the way JS and Rust handles errors are poles apart. Enough of talk let’s start with some code 😋😋.

Before coding anything we need to learn Option and Result in Rust.

Option in Rust represents an optional value: every Option is either Some and contains a value, or None, and does not. Option types are very common in Rust code, as they have a number of uses.

Result in Rust is the type used for returning and propagating errors. It is an enum with the variants, Ok(T), representing success and containing a value, and Err(E), representing error and containing an error value.

enum Result<T, E> {

 Ok(T),

 Err(E),

}

Now let’s see some examples.

First we will learn about Option

fn main() {
    // first let's define vector/array of numbers
    let numbers = vec![1, 2, 4];

    // now let's try to read value from vector
    let index_one = numbers[1];
    println!("value at index {}", index_one);

    // now let's try to read 10th index which doesn't exists
    // since Rust doesn't have neither null nor try/catch to handle error
    // so we will take leverage of **Option**

    // un comment below two line to check error 😢😢

    // let out_of_index = numbers[10];
    // println!("this will throw error {}", out_of_index);

    // above code would result in following error
    // thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 10'

    // rust has very interesting way to handle these errors
    // we will take advantage of Option and get method from
    // vector to handle these kind of errors

    // get method of vector returns **Option** enum
    // Option will have two properties Some and None
    // let's see how to read/catch error
    match numbers.get(10) {
        Some(value) => println!("Hello {}", value),
        None => println!("Yo!! out of bound error")
    }

    // now let's see how to read value from it
    let result = match numbers.get(10) {
        Some(value) => value,
        None => &-1 // defaulting to -1
    };

    println!("result is {}", result);

    // as you can see above code works well but,
    // we can improve code by taking advantage of Result
}

Now, let’s improve above code little bit

fn read_from_vec(input: &Vec<i32>, index: usize) -> Result<i32, &'static str> {
    return match input.get(index) {
        Some(value) => Ok(*value),
        None => Err("Out of bound exception")
    }
}

fn main() {
    // now lets take same example and improve error handling
    let numbers = vec![1, 2, 4];
    let result = read_from_vec(&numbers, 2);

    // now since result is of type **Result** we can handle this in multiple ways
    if result.is_ok() {
        println!("got the value {}", result.unwrap());
    } else {
        println!("yo!! got the error {:?}", result.unwrap_err());
    }

    // above code works but there's an even better way to handle the same
    match result {
        Ok(data) => println!("indexed value {}", data),
        Err(err) => println!("error is  {}", err)
    }

Now let’s see a Generic use case of reading file.

use std::io;
use std::io::Read;
use std::fs::File;

fn read_from_file(file_path: &'static str) -> Result<String, io::Error> {
    let mut file_data = String::new();

    // now let's try to read file
    // here ? is for handling errors
    // if there's an error it will break program and returns error
        // let mut f = File::open(file_path)?;
        // f.read_to_string(&mut file_data)?;
        // return Ok(file_data);

    // we can simplify above code by writing
    File::open(file_path)?.read_to_string(&mut file_data)?;
    Ok(file_data)

}


fn main() {
    // now let's see more generic use cases
    // for error handling

    let file_path = "hello.txt";
    match read_from_file(file_path) {
        Ok(data) => println!("file data {}", data),
        Err(err) => println!("err {}", err)
    };
}

I’m still learning Rust, Hopefully I made some sense about Error handling in Rust Language. If you have any doubts or suggestions you can contact me on my twitter. until then, I will see you in other Post. Peace ❤❤

Modules in Rust Programming Language

sai umesh — Wed, 24 Apr 2019 17:46:08 +0000

If you are new to rust, I would strongly suggest you checkout rust docs at rust they are pretty great.

Modules are one of the better ways to organize your code and reuse it wherever it is necessary.

Rust module system is completely different from what I've used in Languages like JavaScript, GoLang and Python. When I started to learn this pattern, I didn't really like it but, after using them for sometime, now I really like the way it works.

you can find sample code here.

First we will see how to install external modules (crates). To install, all you have to do is goto Cargo.toml add crate name and run you project with command cargo run. once you run this command, cargo will install crate to you project. your Cargo.toml probably might looks like below.

[package]
name = "rust-mod-example"
version = "0.1.0"
authors = ["saiumesh"]
edition = "2018"

[dependencies]
uuid = { version = "0.7", features = ["serde", "v4"] }

now use that crate, may be as below 😁


// main.rs

// this is external crate, which we installed via cargo.toml
use uuid::Uuid;


fn get_uuid() -> String {
    Uuid::new_v4().to_string()
}

fn main() {
    let uuid = get_uuid();
    println!("the uuid is {}", uuid);

}

now let's create a local module and see how we use it.

Before, we write any further code, there are two ways to create mods in rust,
you think in a way that each file and folder is mod in rust.

first we create mod with file


// filemod.rs

use uuid::Uuid;

// pub indicates that, we access this function outside of it's self mod

pub fn get_uud() -> String {
    Uuid::new_v4().to_string()
}

// this is private function which cannot be accessed outside
fn cannot_access() {
    println!("I cannot be called!!");
}


// now in main.rs we will import/define mod by as following 

// now, we have created file called 'filemod'
// which is local mod goes by filename
mod filemod;
use filemod::get_uud;

fn main() {
    // local module which goes by filename
    let file_mod_uuid = get_uud();
    println!("local module uuid is {}", file_mod_uuid);

}

now let's crate a mod, with Folder

as discussed, folder can be a mod, only with slight difference.

when we create mod with folder, that folder should have file called mod.rs

which helps rust to identify this folder as one of the modules.

Folder/{mod.rs, filename.rs}

This might be little confusion but, trust once you get little familiar with it I'm sure you gonna love it.

Now let's create folder called foldermodule, in that folder fist we create mod.rs and then create foldermodulefile.rs

foldermodule/mod.rs

// now make file module public
pub mod foldermodulefile;

foldermodule/foldermodulefile.rs

use uuid::Uuid;

pub fn folder_module_uuid() -> String {
    Uuid::new_v4().to_string()
}

Now let's import this module in main


// now , we have created folder called 'foldermodule'
// which is local mod goes by module called 'foldermodule'
mod foldermodule;
// you use following syntax for importing multiple functions from same mod
use foldermodule::foldermodulefile::{ folder_module_uuid, mod_to_mod_function };


fn main() {

 // local folder module
    let folder_mod_uuid = folder_module_uuid();
    println!("folder module uuid is {}", folder_mod_uuid);

}

Till now we have how to use file/folder modules in main, now let's see how to call a mod function from other mod

now let's create mod

//modtomod/mod.rs
pub mod something;

//modtomod/something.rs
pub fn mod_to_mod() -> String {
    String::from("Hey!! mod")
}

calling mod function from other mod, is little different, you cannot just write use modulename::function_name that would throw out of scope error.

since main.rs binds everything together, you need to define every module in main.rs as below.

main.rs

// till now we have seen using local modules in main file
// now let's see how to do mod to mod rather mod to main
// to use mod in other mod first we need to define called mod in
// main, so that caller mod can have it's scope
mod modtomod;

Now let's go our foldermodule mods call other mod functions

to call one mod function from other module we will use following syntax.


// now let's call other local mod
use modtomod::something; 😢😢

// now let's call other local mod
use crate::modtomod::something; 😁😁

the you call the same function as following code

// now let's call other local mod
use crate::modtomod::something;


pub fn mod_to_mod_function() {
    println!("hey!! from other mod {}", something::mod_to_mod());
}

Hopefully I made some sense about modules in Rust Language. If you have any doubts or suggestions you can contact me on my twitter. until then, I will see you in other Post. Peace ❤❤

DEV Community: sai umesh

Slide, a Go web framework for developers coming from Express.

Motivation

🚀 Example

Features

Express

Slide

Nested (Grouped) Routes

Express

Slide

Files

Rust Ownership and Borrowing

Error Handling in Rust programming language

Modules in Rust Programming Language

saiumesh535 / rust-modules-example

Module in Rust

rust-modules-example