DEV Community: YJDoc2

Two Rust features that I miss in Other languages

YJDoc2 — Thu, 13 Apr 2023 14:35:34 +0000

Hello everyone!

Now-a-days I am writing code in several different languages : Rust, C , JavaScript, Python. While all of these have their own use cases , Rust is one of my favorite languages in which I enjoy writing code in.

I have been writing code in Rust for about 1.5 - 2 years now, and it is still just as fun (if not more) as it was when I started. Rust has many great features which makes it different from others, and all of them have their own pros and cons. However, there are some features in Rust which I miss when writing code in other languages.

In this post, I'll be talking about two such features : One which you might know and be familiar with, and one which you might not know directly. I think both of them are valuable not only for better code, but even from a developer's perspective, and helps me to think clearly and write better code.

Error Management

Now, I don't mean to say other languages do not have error handling. Its just that the way Rust does error handling has an elegance and simplicity , which I miss in other languages.

I truly feel that Rust has done a great job with error handling. Even if not everyone might agree with the particular way it is done , I still feel it is one of the best error handling ideology that I have seen.

Error handling in Rust gets divided into two distinct types of errors :

Recoverable/ "true" errors : This is the most common one, which is almost entirely supported by Result enum. These kinds of errors are something that you know might occur, and want to bubble up, or display to users.
Non-recoverable / "exceptions" : These are signified by panics and unwraps. These signify that some invariant is broken; or that some basic assumption which should have been true, is actually false. In such cases there is really no point on continuing, and crashing is a better option.

Most of other languages do not separate these two kinds.

Java, Python, JS only have Exceptions, a single mechanism which must be used to indicate both ; or we must have an error:true/false field in all return types, and caller must check before using the returned value.
C has errno . To start with, it is a global variable for the whole code, and there is not much support to attach custom error messages without doing something similar as returning an enum with error and data components.

Update : As some have pointed out in the comments, Java and scala has an Either type somewhat equivalent to Result in Rust, and Go has error wrapping. I missed them originally when writing, as I do not work with these languages much.

Rust separating these two kinds allows me to think on what possible errors might occur - all known possible errors are declared upfront along with the return type, and only unexpected errors can cause crashes at runtime.

Apart from that, I think Rust has beautiful syntax support, which makes it feel that error handling was a first-class thing, not just an after thought.

? operator allows bubbling up errors in a clean way. No need to have only a top level catch, or do a catch-check-rethrow.
unwrap() calls indicate what are our base assumptions for the code.
unwrap_or and similar APIs on Result allows setting a default / sane fallback in clean way.

Because of such nice support, there are quite a few libraries which build on top of this and allows us to have more good things :

anyhow is one of the GOAT crates, allowing to bubble up many error types from a single function, and attach context to errors
eyre is a fork-extention of annyhow, and provides way to derive error types and reports for structs

consider the following which uses anyhow crate :

...
let result1 = function1().context('function 1 errored')?;
let result2 = function2(param1).with_context(|| format!('function 2 errored with param {param1}'))?;
let result3 = result1.update(result2).context('update with result2 failed')?;
...

In this way we can attach context to each individual error at each step, without having to add any additional piece of code. To the best of my knowledge, there is no straightforward way of doing something similar in other languages.

Consider doing similar in JS : if we use Exceptions to indicate errors, we either have to wrap all three in single try-catch and lose the granularity of context ; or have a try-catch for each, attach context to the caught error and re-throw from the catch block. This quickly gets out of hand as the code grows and there are more possible points for errors.

#[must_use] Annotation

Even though #[must_use] is not directly a part of Rust syntax / language itself, I think this is one of its underrated parts.

#[must_use] does not modify the code's output in any way, however it provides a lint which can be very helpful for catching some easy-to-miss bugs.

When we annotate any type with this, values of those types must be used. Consider the Result type which is annotated with #[must_use]. If we call a function which returns a result, but do not use / capture that return value :

result_returning_function();

we will get a compiler warning saying

warning: unused `Result` that must be used

Thus, we can make sure all Results are acknowledged, and we do not accidentally miss any potential error.

This also beautifully integrates with Futures. As Futures must be polled for them to resolve, if we create a future, but do not await it, we get a warning such as

warning: unused implementer of `Future` that must be used
...
note: futures do nothing unless you `.await` or poll them

Finally Rust stdlib itself uses this to warn us of some gotchas. For example wrapping_add and such methods are directly called on values, but do not modify those values, but instead return a new value. One can easily forget this, and assume that the original value is modified. This warning prevents us to miss it easily.

As far as I know, no other language has anything similar, even considering external linters. I miss this specifically in JS, where there are no ways to ensure async functions are (eventually) awaited when called. Because of that, I sometimes miss awaiting a single async function call in async context, and that single function runs asynchronously, while rest do not.

Having the #[must_use] or equivalent would make catching such errors much easier.

Thank you for reading! Are there any other features of Rust you miss when coding in other languages? Or Any features of other languages that you miss when coding in Rust? Feel free to let me know your thoughts in the comments :)

Announcing Youki 0.0.4 🎉🎉🎉

YJDoc2 — Wed, 14 Dec 2022 16:07:33 +0000

Hello everyone!

For about a year now, I have been doing some open source contributions to a great project called Youki. It is a low level container runtime, written in Rust language, which aims to be similar to existing runc or crun projects, with its own advantages. It has been immense fun to contribute, and I have learnt a lot while doing this, right from writing docs, figuring out stuff in a complex code base to Linux internals such as namespaces, cgroups, and processes.

Today, we are announcing version 0.0.4 of Youki.

In this release

last release of v0.0.3 was done in April, and this release brings some pretty exciting updates to Youki :

Now Youki passes all of the contained integration tests, which means it can be used a runtime with containerd like runc or crun
Adds support for WasmEdge, which is one of the fastest WASM runtimes
And Many More!

The Full changelog + release notes can be seen here : https://github.com/containers/youki/releases/tag/v0.0.4

Thanks to everyone who contributed and helped us achieve this!

Personally, I'd also like to especially mention utam0k and Furisto who helped me a lot!

Check out Youki at its github Repo :

youki-dev / youki

A container runtime written in Rust

youki: A container runtime in Rust

youki is an implementation of the OCI runtime-spec in Rust, similar to runc.
Your ideas are welcome here.

🏷️ About the name

youki is pronounced as /joʊki/ or yoh-key youki is named after the Japanese word 'youki', which means 'a container'. In Japanese language, youki also means 'cheerful', 'merry', or 'hilarious'.

🚀 Quick Start

Tip

You can immediately set up your environment with youki on GitHub Codespaces and try it out.

$ just build
$ docker run --runtime youki hello-world
$ sudo podman run --cgroup-manager=cgroupfs --runtime /workspaces/youki/youki hello-world

User Documentation

🎯 Motivation

Here is why we are writing a new container runtime in Rust.

Rust is one of the best languages to implement the oci-runtime spec. Many very nice container tools are currently written in Go. However, the container runtime requires the use of system calls, which requires a bit of special…

View on GitHub

We also have a nice documentation up at https://containers.github.io/youki/ for both users and developers, come take a look!

What is stopping you from learning C?

YJDoc2 — Fri, 02 Dec 2022 15:34:40 +0000

Hello Everyone! Today I have a question for you ->

C

I like C. I'd go even as far as saying C is one of the most beautiful languages out there. Yes, you can shoot yourself in the foot easily, and Yes, it is tedious to do complex stuff in it, but those are good reasons why one might not want to use it for stuff, not why you shouldn't want to learn C.

C is one of the minimal languages, with fairly simple syntax, and if there is anything you want to do using a computer, you can do it using C 99.9% of the times¹.

No, You should not use C for everything.

I like C. But I will not suggest using it for everything, especially when today there are many languages, each having their own advantages and disadvantages for any particular task :

Writing a web application? Hard to beat JS or Elm
Want to check out something quickly, or do data-wrangling? Python might be a good fit
Want to write a very stable application with helpful compiler and sanity checks? Rust.
Maths and graphs? R, Matlab, Python+matplotlib - take your pick
Want to effectively communicate with others without misunderstandings? maybe use ???²

But anyways - I will not suggest using C today for doing everything, especially when there are better alternatives. But again, this is an argument for not using it, not for not learning it.

Then why to learn C

You might be getting a feeling that I like C. It is correct.

With the above examples, why would I suggest learning C anymore? It does not seem to be used that much, it is not that easy to write stuff in, then why?

Well, C is still used a lot, only we don't really get to see a lot of it.

Most of the Operating systems that are used today - Linux, Microsoft, MacOS, Android; are written mostly in C, with a dash of assembly and hint of other languages. So whatever you are reading/listening this on, you can thank C for making it work
Embedded systems still hail C. From dials on your devices, smart appliances and whatnot, C still rules the embedded world with the help of assembly. So next time you use your digital dial on something, you can thank C for making it work.
Almost all of the drivers needed to make hardware work with your machine uses primarily C. There might be other languages thrown in the mix, and there might be some languages trying to take its thrown, but C still stands supreme here. So when you get a new graphics card, or plug-in a mouse and it-just-works(TM), You can thank C³.

But you say you are never going to do that?

Being a person who is interested in Systems and OSs, I like C. And those who are reading and also interested in it might already be interested in C.

But the small number⁴ of other people who do stuff like web-dev, might never want to deal with it, so why should they bother learning it?

Well, unlike the myth, C might not be the "closest" language to the hardware anymore ; but it still is one of the most down-to-earth⁵ languages out there. You will still get a lot more understanding of how your computer works, and how the JS interpreter and browser that runs you code and displays your site works under the hood.

It is also a strictly typed language, so you will get a feel of keeping in mind what type your data is when passing around. It can still be useful as a sub-conscious check when using duck-typed languages, to avoid req.redirect is not a function or myAwesomeVar.myAwesomeProperty is undefined errors. Don't they just hurt when your code is deployed and crashes, just because that one particular path of execution was missed when you were testing it?

So Should you learn C?

Me, liking C , will say yes. No you should not use Only C and No you should not use C everywhere, but I feel it is worth the effort to learn C and do some small projects in it. It can be a lot of fun and help you understand a lot more about the immensely powerful machines⁶ that we hold in our hands.

But it might not be easy to do so. Maybe you have tried and stopped, maybe you tried really hard and just couldn't. And I'm interested to know what was it. What is stopping you from learning C.

What stopped me from learning C

Before I started really liking C, there was a time where C felt really confusing, and I also didn't really understand why I should learn C.

For me the reason that was stopping me was the concept of pointers. It took me about three tries with three different approaches to it, before I could finally understand what are pointers and why they are useful.

Funnily enough, the way I finally understood them had hardly anything to do with learning C : I was reading a book on Linux and its features and stuff, and it had a lot of C programs in it as examples of Linux programming. I didn't understand half the things I read about Linux then, but it helped me to get my concept of pointers cleared.

And so now I want to help others as I can. I am thinking of writing a book-as-blog⁷ in which I intend to start from the very basic concepts, and try to write what I know about C. And for that to be useful, I need to know what do you find difficult when learning about C.

So please help me, and tell me : What is stopping you from learning C? It can be as simple as you never wanted to, or you never really knew why you should, or maybe a concept that you felt was difficult enough to stop learning C. Those who have learnt C and enjoy it, please let me know what resources did you use? Did you find anything particularly good that helped you learn C?

Looking forward to your comments.

Oh, and in case you didn't notice, I really like C.

Thanks for reading!

Cover image credit : By Rezonansowy - This file was derived from: The C Programming Language, First Edition Cover (2).svg, Public Domain, https://commons.wikimedia.org/w/index.php?curid=29423032

Rest 0.1% is when you are dealing with hardware at its bare-most level, eg. bootloaders ↩
This probably is NP-hard, bordering on unsolvable ↩
And the people who do the tedious task of writing and distributing those drivers too. Those also deserve more recognition and love! ↩
See proof at https://dev.to/derlin/devto-is-for-webdevs-and-beginners-i-have-data-to-prove-it-54c4 ↩
Read down-to-silicon 🥁 ↩
https://xkcd.com/676/ ↩
Sometimes also referred to as blog-as-book ↩

Introducing PCB-rs : Making it easier to write hardware

YJDoc2 — Fri, 08 Apr 2022 14:20:04 +0000

Remember the post I wrote about 2 months ago ? Asking why you don't write much hardware?
In it I said I was writing a library to make it easier. Well, I have completed the initial release version of it 🎉 🎉 🎉

Quick note : I don't usually ask this, but please share this article, or directly the library on your socials or such! I have spent quite some time on developing it, and I really want people who can benefit from this to use this. Your share might help this reach someone who needs it. Thank you!

So, what is it?

Well, I'm happy to share with you : pcb-rs ! This is a library which will make it much easier for you to write hardware components, and simulate them. It does this by giving you two proc-macros, which you can use with your run-of-the-mill structs and it will generate the interface implementation for you!

Why ???

Because I want to make it easier for people who wish to explore hardware to do so. This does not aim to be the perfect and most-accurate-simulation ever ; or try to replace VHDL, (because it does not). This aims to be a rung in the ladder from high-level programming language to hardware level. That way those who are just starting to explore it, will have to jump a little less height : they can still work in comfort of Rust, but can have the taste of things that one has to consider when designing hardware.

It is choose-your-own-difficulty hardware design!

Show, don't tell

Here I'm showing how you can write a simple 256-byte RAM as a hardware component using my library :

use pcb_rs::Chip;

#[derive(Chip)]
pub struct Memory {
    #[pin(input)]
    addr: u8,
    #[pin(io, io_latch)]
    data: Option<u8>,
    #[pin(input)]
    is_active: bool,
    #[pin(input)]
    is_read: bool,

    io_latch: bool,
    pub mem: [u8; 256],
}

impl Chip for Memory {
    fn tick(&mut self) {
        if !self.is_active {
            self.io_latch = true;
            return;
        }
        if self.is_read {
            let addr = self.addr as usize;
            let data = self.mem[addr];
            self.data = Some(data);
            self.io_latch = false;
        } else {
            let addr = self.addr as usize;
            let val = self.data.unwrap();
            self.mem[addr] = val;
        }
    }
}

Here the derive(Chip) is my prco-macro which automatically implements the required traits for your chip, and you just have to write impl Chip which defines the processing logic of your chip.

Thus in about ~33 lines, we have a working RAM. This is also modular - it can be used with other components, such as CPU 🎉 🎉 And pcb-rs also provides another macro for that :

pcb!(PCB{
    chip cpu;
    chip mem;

    cpu::addr_bus - mem::addr;
    cpu::data_bus - mem::data;
    cpu::mem_active - mem::is_active;
    cpu::read_mem - mem::is_read;

});

Yep. That's it. That's all you have to define to interface a CPU and the RAM. the pcb! macro will parse this, derive the logic for validating the chips given to it , derive the logic to verify the pin connection, derive the logic for passing values from one chip to another, and write the builer and pcb struct.
Now to actually place the RAM and CPU pins in it:

let mem = Box::new(Memory::new());
let cpu = Box::new(CPU::new());
let temp::PCBBuilder = PCBBuilder::new();
let temp = temp.add_chip("cpu", cpu).add_chip("mem", mem);
let mut pcb:PCB = temp.build().unwrap();
pcb.tick();

This will place the chips in the builder, validate that correct chips have been placed, and give you the PCB struct, which contains all the running logic after calling build. The PCB itself will have the tick() method, which will run your chips.

And you know what, this itself is modular! You can use such chips as part of some other PCB, and so on 🎉 🎉

Wait, you're telling me this is easier?

Well, yeah! This will allow you to write Hardware components from comfort of Rust, before you get into something more complex as VHDL. Also you have to write just the struct and annotate what members you want to use as pins, and then write the processing logic for the chip. Everything else is derived by the macro for you.

Same for pcb, you just have to define the chips, connections and what pins you want to expose to others, rest, including the actual struct, will be derived by the macro.

Ok, show me more

I know this is pretty different that what many of you might be usually doing. So, as examples, I have written several components that range from pretty basic to a bit complex.

You know what's more? As Rust can compile to WASM, I have also done that and have made a web interface for the examples. You can run them directly from your browsers. Check it out at https://yjdoc2.github.io/pcb-rs-examples/.
Currently the examples consist of :

Basic gates such as Not, And, Or, Xor wikipedia
Ripple carry adder wikipedia
Look ahead Carry adder wikipedia
SR, D, T, JK Latches wikipedia
Straight and Twisted Ring counters wikipedia
CPU and PCB example which I showed above

You can try all these right in your browser, at https://yjdoc2.github.io/pcb-rs-examples/.

I made these particular examples, as these are usually a part of basic hardware/electronics course, so these will be a good taste of how pcb-rs library can be used for that.

Links, Links and Links

So,
The library :

YJDoc2 / pcb-rs

A library to easily write software emulated hardware

Pcb-rs

A library to easily wite Software Emulated Hardware

This library provides two macros Chip and pcb which can be used to write software emulated hardware components. Chip is a derive macro which can be used on structs to automatically implement the necessary interfaces for the struct to be treated as a Hardware Chip, and you only need to implement the tick function which will be called on each clock cycle to run the logic of your chip. pcb macro is used to define a PCB , where you can connect multiple chips, and it will manage connecting pins of chips, verifying the connections and passing the data on the connected chip.

One of the aims of this library is modularity and reusability, thus the pcb created can be further used as chips in some other pcb ans so on.

There are some finer points to be noted when creating…

View on GitHub

The examples :

YJDoc2 / pcb-rs-examples

Repository containing examples of usage of pcb-rs

PCB-RS Examples

This repository contains examples to demonstrate use of pcb-rs. To see more information about what is pcb-rs, the reasoning behind it, and basic syntax and examples, visit its repository at https://www.github.com/YJDoc2/pcb-rs.

This repository contains various examples on how to write components, as well as how to reuse components from other libraries to create a composite component. Each of the directories contain their own readme describing the that particular example.

The web version of these examples is hosted at yjdoc2.github.io/pcb-rs-examples/, so you can try them right in your browser without needing to install anything, as well as show the possibilities with this library and WASM for making such electronics related tools and simulations.

Various directories in this repo contain different examples, and their details are explained in their own readmes in that directory. Currently this repo contains following directories :

Basic Gates : This contains basic…

View on GitHub

The Web interface for the examples : https://yjdoc2.github.io/pcb-rs-examples/.

And ...?

Go Check It Out!!! Try it out in your own projects, share the projects and let me know how are you using it!

And as I said in the start, I don't usually ask this, but please consider sharing this. I really want this to help people who want to get into hardware. Your share will help this reach more people.

Also if you think this is interesting, consider starring it on GitHub. That might also help getting this more attention.

Let me know in comments your thoughts and reviews for this.

Thanks a lot for reading!

Note : header image is taken from google images search, and is not mine.

What is keeping you from dabbling in writing Hardware ?

YJDoc2 — Sat, 19 Feb 2022 14:32:45 +0000

Let's face it, if you are writing any program, in any language : you need hardware to run it.

If you write C / C++ / Rust code it will compile to binary which will execute inside you processor (eventually) and if you use python / JS it will run on top of their interpreters, which themselves run on the hardware. One way or other you will have to use hardware to execute your code. I hope we can agree on this 😉 😉

Hardware such as CPU does some really amazing things , latest CPUs have pipelined processing, so that they can run multiple instructions at the same time, and also logic to detect if the next instructions can run at the same time or not. They have several 128 bit-and-more registers which can process floating numbers and strings crazy fast, parallely and with various options : Do you know there is an instruction in x86 instruction set ( one used by common Intel and AMD CPUs) that can check if a substring is present or not in given string?

I agree that at the beginning it can be hard, even outright scary to get into such low level of systems, where everything is in binary and you have to take into consideration the things that you didn't know existed. But as with any other programming / coding / computer related stuff, I think it can get more manageable, if not easy, if one works with it more.

Think about the first website or app or any project that you made, and how complex or technical it seemed at first, and how hard it seems after having done it several times after. The more you play with it, the more you try and make mistakes, I feel the better you get at it.

So, what is stopping you from getting into something so cool as hardware ?

In my case :

To buy and work with actual Hardware, like Raspberry Pi, involves some cost, and even then I'm still working on an API abstraction of some libraries (usually)
For designing actual hardware at the low level, current options usually involve VHDL or Verilog like softwares, and it can get pretty complex pretty soon, even to implement something very simple. Don't get me wrong, those s/w are pretty amazing, they can Optimize the circuits you wrote,and can be used to actually synthesize stuff that can be etched onto FPGAs , Which is pretty cool! But for a beginner who want to write few chips, the overhead can be tedious.

So, mainly because of the point 2, I am currently working on a library in Rust which will make it easier to write s/w emulated h/w in Rust. The complete logic of your chip will be in Rust, you can access files and stuff if you want, and do anything that Rust can do. The way I'm thinking, it will be as simple as writing a struct/class, annotating which pins are input, output and a function to operate what the chip will actually do based on the values of those pins.

Now this won't help you write Intel Pentium in 100 lines of code. Even emulators for Intel 8086, which was released in 1987, take about 2000-5000 lines of code (I would know, I have written one).

That said, this will allow you to ignore how to connect pins of various chips or how to write interface to connect chips and allow you to focus on the logic of the chip, like how 4-bit binary adders add two numbers or how ring counters actually count, or how a CPU actually reads the data from RAM and so on. This also aims to make them sharable so you can take RAM someone else wrote and interface it with you CPU, just like you would use different modules or packages for a project.

Even though I am writing it in Rust, the logic behind it does not depend on Rust, so one can easily do the same in Python or JS, and maybe even use Rust components with them.

I will share it once the things are done, but in the meantime I would like to know what is keeping you form dabbling in writing s/w emulated h/w. Maybe I can add features which will solve your issues too. Let me know in the comments!

PS : if you want to know when I publish the library, follow me 😉 you can unfollow after I publish it , I won't mind 😄

Thank you!

Note : all images are taken from google images search, and are not mine.

A Rust macro which will derive Bytecode for you

YJDoc2 — Tue, 04 Jan 2022 11:43:40 +0000

Hello!

I made a Rust proc-macro which will compile and parse your enums and structs to and from a bytecode for you!!!

YJDoc2 / Bytecode

A Rust proc-macro crate which derives functions to compile and parse back enums and structs to and from a bytecode representation

Check it out and star it if you think it is interesting!

Why

Consider you are writing a VM, and need a bytecode representation for your opcodes, to store it in the VM's memory. You might consider something like this :

pub enum Register{
    AX,
    BX,
    ...
}

pub enum Opcode{
    Nop,
    Hlt,
    Add(Register,Register),
    AddI(Register,u16),
    ...
}

If you try to write functions to compile and parse these two enums to a simple bytecode, it would be something like this :

impl Register{
    ...
    fn compile(&self)->Vec<u8>{
        match self{
            Register::AX => vec![0],
            Register::BX => vec![1],
            ...
        }
    }
    fn parse(bytes:&[u8])->Result<Self,&str>{
        match bytes[0]{
            1 => Ok(Register::AX),
            2 => Ok(Register::BX),
            ...
            _ => Err("Invalid opcode")
        }
    }
    ...
}

impl Opcode{
    ...
    fn compile(&self)->Vec<u8>{
        match self{
            Opcode::Nop => vec![0],
            Opcode::Hlt => vec![1],
            Opcode::Add(r1,r2) => {
                let mut v = Vec::with_capacity(2);
                v.extend(&r1.compile());
                v.extend(&r2.compile());
                v
            }
            Opcode::AddI(r1,v1) =>{
                let mut v = Vec::with_capacity(3);
                v.extend(&r1.compile());
                v.extend(&v1.to_le_bytes());
                v
            }
            ...
        }
    }
    fn parse(bytes:&[u8])->Result<Self,&str>{
        match bytes[0]{
            1 => Ok(Opcode::Nop),
            2 => Ok(Opcode::Hlt),
            3 =>{
                let r1 = Register::parse(&bytes[1..])?;
                ...
            }
            ...
            _ => Err("Invalid opcode")
        }
    }
}

Even for the two instructions I have shown, this is pretty long, tedious and boring.

And now consider doing this for at least 25 to upto 100-ish opcodes, as you might need. 😟 😰

And now consider you want to remove a variant or add a variant in the middle of an enum 😰 😱

You will need to shift all the values accordingly, manually.
Not Fun.

The macro will do this for you, and let you concentrate on implementing your VM.
Fun. (hopefully).

Links

The GitHub contains more information and detailed example of usage, so go check it out and ⭐ it !

YJDoc2 / Bytecode

A Rust proc-macro crate which derives functions to compile and parse back enums and structs to and from a bytecode representation

Bytecode

A simple way to derive bytecode for you Enums and Structs.

What is this

This is a crate that provides a proc macro which will derive bytecode representation of your enums and structs, and provides compile and parse functions to convert to and from the bytecode. This also provides necessary traits to do so, in case you want to do it manually.

Note : The values of the fields are compiled as little-endian values, so in the bytecode the smallest byte is at smallest location. The bytecode itself is Big-endian for certain reasons.

Example

Cargo.toml

...
[dependencies]
...
bytecode = {git = "https://github.com/YJDoc2/Bytecode" }
...

Code

use bytecode::{Bytecodable, Bytecode};
#[derive(Bytecode, Debug, PartialEq, Eq)]
pub enum Register {
    AX,
    BX,
    CX,
    DX,
}

#[derive

…

View on GitHub

Thank you!

How many (Human) Languages you know?

YJDoc2 — Thu, 25 Nov 2021 14:35:58 +0000

Hello!

Sometime ago, after coding for a bit too much time, I thought of learning a new human language as a distraction. Even though I didn't follow through on that thought, I am curious now, how many of you know multiple human languages? Which ones do you know?

How did you learn them? Did you find any interesting resources, or did you take some classes or courses? Did you also, like me, try learning something as a distraction or hobby?

On that note, if you do know multiple languages, do you feel that knowing multiple human languages helped you be a better developer?

Please let know in comments!!!

Thanks :)

I Used KDE Plasma to Make Ubuntu Look (Somewhat) like MacOS

YJDoc2 — Thu, 28 Oct 2021 13:32:41 +0000

Hello!

I recently updated my Ubuntu Gnome desktop to look somewhat like MacOs. (or at least what I think looks like MacOS 😄 😄)

The process was quite straightforward, and apart from a couple of minor issues, I feel it is quite good to use.

Also mandatory disclaimer for Linux posts : Yes you can customize anything to look like anything, I chose this way , but you might be able to do it in some different way.

Warnings before the spells (😉)

Even though this looks great, and personally I didn't feel any problems when using it on daily basis, I did encounter some issues :

The default linking of file format to apps is not retained : for some reason the file-formats are not linked by default to certain apps, for example, by default, it tried to open .zip files with imagemagick, and a pdf with gimp, even though archive manager and document viewer were installed ?! But this is a first time issue only, you can set the default app when opening and then that will get picked next time
Font size for some apps is changed : I use Alacritty+Zellij for my terminal emulator, and the default font size of it was perfect in Gnome, but in KDE plasma, by default the size is larger. This can be fixed by changing font size by ctrl+ +/- , but it is not retained across sessions.

Other than in I haven't found much issues when using KDE plasma, and in fact, personally, it feels much better than Gnome. Even it feels like it is faster than Gnome for power on to usable desktop.

Final results

Finally the desktop looks like this :

So If you want to see how to do this, read on 😄 😄

Install KDE Plasma

Now to do that first, you need to install KDE Plasma desktop environment. In case you use a distribution which comes with it, like Kubuntu, you can skip this step, otherwise you'll need to install this.

Now there are three packages that you can install, which will install plasma, and the main difference is the rest of the stuff they com with :

kde-full comes with all the bells and whistles, all the plasma compatible packages and stuff. For that very reason, it is quite heavy, and has size around 1GB
kde-standard is a medium sized version which comes with minimum requirements, and a few packages up top.
kde-plasma-desktop contains the bare minimum of kde plasma

I didn't want to install a full-on set up, and even the standard seemed a bit extra to me, so what I chose, was to install kde-plasma-desktop and then install few more packages which I thought were necessary on top of it.

To see which extra packages kde-standard installs, run

# you don't need sudo for this
apt-cache depends kde-standard

This will display a list of all dependencies of kde-standard, and you can pick-and-choose which of them you want to install on top of kde-plasma-desktop.

You can check what each package is for from the official kde-plasma app website : https://apps.kde.org/

For me, I installed :

ark : an archive manager
kate : simple document editor, similar to gedit
kcalc : calculator
muon : graphical package manager (don't look at me like that )
okular : document viewer
plasma-dataengines-addons, plasma-runners-addons, plasma-wallpapers-addons, plasma-widgets-addons, which are plugin/addon helpers,
plasma-pa which is audio manager
polkit-kde-agent-1 which is policy manager

The total size of all this, along with kde-plasma-desktop was around 200-ish MB.

You can simply use sudo apt-get install ... for installing all these, or use your distribution specific packge manager.

Note

When installing these, at the time of kde-plasma configuration it will ask you to choose a display manager. For me the choices were gdm3 which is what gnome used, or sddm which kde plasma uses. For plasma to work properly, you need to choose sddm here. I went back to Gnome , still running sddm, and it seemed to work fine, but if needed you can revert back by using

sudo dpkg-reconfigure gdm

which will give you choice again, where you can choose a different display manager.
For making KDE plasma work best, choose sddm.

After installation, you should restart the system, and at the login screen, there will either be an option to choose your desktop manager, or by default it will boot in kde-plasma. For me it by defualt booted into kde-plasma.

Follow a YouTube tutorial

This is step 2. Seriously. The whole reason I decided to change my desktop environment was that I saw this, and it felt really cool.
So follow this to the details (as much as you can) :

link : https://www.youtube.com/watch?v=A0LiFu1eaMs
Also, in case you don't know this channel, this is a great channel if you're interested in Linux news and related stuff.

My personal changes

The defaults in the above video are pretty good, but I needed to change few things to make it final :

The layout file comes with icons links in docks for many apps which I haven't installed, so on the dock there were many broken links, so I removed them.
I needed to enable tap-to-click and natural scrolling through system settings > Input devices > touchpad as I use a laptop
I made the top bar span end-to-end of the screen, instead of 98%
In the video, the system has a dark theme by default, as he has previously installed a dark theme, but by default you will notice many system panels are still white. For that go to system setting > Appearence > Get new Global theme, and install Layan look and feel theme. Choose the dark theme, and this will apply dark theme globally.
I couldn't find the thumbnail task switcher, so I installed MediumDefault in System Settings > Window Management > Task Switcher
I also disabled desktop icons through right click on desktop > configure desktop and wallpaper > wallpaper > layout and choose desktop instead of folder view
I also reverted the window buttons to the right side, and kept the maximize button, as that felt better to me
I also added an extra application launcher widget in the dock

That's how I got the system I am using now. It looks cool, and feels nice to use 😄 😄 😄

In case you decide to change your desktop as per this, let me know how kde-plasma feels to you in comments. If you already have a setup that looks and feels cool, please post its pictures in the comments too, I would really like to see them :)

Thanks for reading!

Notes:

How to install kde plasma : https://itsfoss.com/install-kde-on-ubuntu/
find reverse dependencies : https://askubuntu.com/questions/135267/whats-the-difference-between-kde-packages
Remove desktop icons : https://www.reddit.com/r/kde/comments/6vfvxj/how_do_i_turn_off_folder_view_desktop_on_plasma/

How to squash commits in a PR

YJDoc2 — Fri, 27 Aug 2021 11:01:10 +0000

Helped by Palka , Parth, and Yatharth.
Header image created by Saloni. Git illustration in text created by Milan

Hello everyone !
As you might be aware, hacktoberfest is approaching, and in about a month many of you will be helping out on open source projects. Of course, working on projects is a side effect, you know why we really do it...😏😏 To plant a tree, obviously 🌳🌲🌳🌲 (Seriously, we should do that seeing the amount of wildfires this year)

Anyway, while making PRs, you might be asked to squash formatting or spelling error commits, and to save you a Google search, I am writing this post to show you why, when and how to squash commits in your PR.

Why would you ever want to squash something???

So imagine this, you have written your beautiful code, written comments in a well known format, the code is compiling and working, and you satisfyingly make a commit with the perfect commit message.... Only to realize later that you have made a spelling error 🥲🤦 Now you can use a soft reset, fix the error, and re-commit, leaving no one any wiser, but what if you had already pushed the commit in PR?

More realistically, imagine you're working on a PR, and as you're pushing the commits, and they're getting reviewed you accidentally mess up formatting and commit. Or along an ongoing discussion in a PR, you have made some patch commits and now before merging the PR you want to combine them, as old patches don't really make sense . This is where squashing the commits would come handy.

Squashing allows to combine or 'squash' the commits together, leaving a nice git history behind. That way you can combine all your patch commits into a single commit, or squash formatting and spelling error commits into other commits, leaving behind a git history of only necessary commits.

When should the squashing be done?

Now on an important note, you should not squash commits if they're pushed to the main branch of the repository. Squashing changes git history, which means that history of all forks of that branch will be inconsistent with your repository, giving everyone a lot of merge conflicts, and you know how you were when you got conflicts, right 😉 😉

However if you're working on a branch which is not main for an issue, and you intend to make a PR to the main branch, it is totally fine to squash the commits. As most of the times you alone are working on that specific branch, even if the history changes it will not affect anyone else. Then once everything is done, you can merge the PR without any history conflicts.

How to squash commits

Let us see with an example. Consider a project on which you're working, that already has some commits on its main branch.

# run git log --pretty=oneline
7dc92d4...(HEAD -> Main) Add ReadMe
d3395b0... Initial Commit

Now to grow some trees 🌲🌳 you decide to work on this project and help in solving issue-1. So you fork and clone the project, make a branch named issue-1 like a good contributor and start working on the issue.

You add feature 1 and feature 2 in their own commits and make a PR. After discussing with the reviewers, you find that there was a bug in your commits and you make a commit to fix it.

Now, your git history looks like this

# git log --pretty=oneline
b2f4c83... (HEAD -> issue-1) Bug Fix
32e414f... Add Feature 2
7654633... Add Feature 1
7dc92d4... (Main) Add ReadMe
d3395b0... Initial Commit

You have your main branch's head on Add Readme commit, and issue-1's head on Bug Fix commit.

Now as you're about to start with feature 3 , when someone comments on your PR, noticing a formatting and spelling error😭😢
Ah well.... You fix those, make a commit and start working on the feature 3. After finally making if work, your commit history now looks like this

# git log --pretty=oneline
f592171... (HEAD -> issue-1) Add Feature 3
574b345... Fix Formatting
b2f4c83... Bug Fix
32e414f... Add Feature 2
7654633... Add Feature 1
7dc92d4... (Main) Add ReadMe
d3395b0... Initial Commit

As you push these to your repository, and wait eagerly to get it merged, someone asks you to squash the formatting commit, so the main repository history would look nice.

Now to squash the commits, you need to run

git rebase -i HEAD~4

The -i option make the rebase interactive, and HEAD~4 considers last 4 commits from current Head position for the rebase. If your formatting commit was 5 commits before current, you would replace 4 with 6 or some numbers greater than 5, to get all commits till there.

After running this, you will see a message like

pick 32e414f Add Feature 2
pick b2f4c83 Bug Fix
pick 574b345 Fix Formatting
pick f592171 Add Feature 3

# Rebase 7654633..f592171 onto f592171 (4 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

This shows first, the commits : from oldest to latest, and then available options, such as squash, edit, fixup... Git can be really powerful once you get to know it... But I don't know much of it other than handful of commands, so let us get on with squashing the formatting commit.

To perform an action on a commit, you change the word 'pick' before that commit to that action, as described in comments. To squash the formatting commit, you change it as

pick 32e414f Add Feature 2
pick b2f4c83 Bug Fix
squash 574b345 Fix Formatting
pick f592171 Add Feature 3

After saving this you will get another commit message, showing commit message before the squashed commit, and the squash commit message.

# This is a combination of 2 commits.
# This is the 1st commit message:

Bug Fix

# This is the commit message #2:

Fix Formatting

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
#
# Date:      Thu Aug 19 19:03:51 2021 +0530
#
# interactive rebase in progress; onto 7654633
# Last commands done (3 commands done):
#    pick b2f4c83 Bug Fix
#    squash 574b345 Fix Formatting
# Next command to do (1 remaining command):
#    pick f592171 Add Feature 3
# You are currently rebasing branch 'issue-1' on '7654633'.
#
# Changes to be committed:
#       modified:   readme.md
#

In case the commit was something like a patch in series where you want to keep the message, this will allow you to do that. Otherwise if you just want to forego the message, you can also use the fixup instead of squash. Here you can comment the second commit message, and save, like usual git commit.

# This is a combination of 2 commits.
# This is the 1st commit message:

Bug Fix

# This is the commit message #2:

# Fix Formatting

# Please enter the commit message for your changes. Lines starting
...

# git log --pretty=oneline
29768cb... (HEAD -> issue-1) Add Feature 3
10c38d8... Bug Fix
32e414f... Add Feature 2
7654633... Add Feature 1
7dc92d4... (Main) Add ReadMe
d3395b0... Initial Commit

Ah, now you have a clean git history, alas, if you try to push this to your repository branch, you will get error saying cannot push because histories are different. Your repository has the formatting commit whereas your local has no such thing in its history. To fix this you'll have to force push :

git push -f origin issue-1:issue-1
# as you're on issue-1 branch, you can leave the last part, but I like the extra confirmation

With this your PR will be updated, hopefully merged, and you'll be one step closer to planting that plant 🌱

Hope you found this useful, and may your PRs be clean :)

Since I started this post talking about hacktoberfest, let me end with the same. Do you have any repository that you plan to open up for contributing to this hacktoberfest? Sometimes it is hard to make your repository visible in all repos open for contributing, so this is kind of an early call... If you have any interesting repo you would like to open for contribution, post them in the comments. Let's start planting the trees. 🌱🌱🌱

Completely Oxidizing My Terminal Setup

YJDoc2 — Thu, 22 Jul 2021 10:44:00 +0000

Hello!
I recently oxidized my terminal setup, by converting all of my terminal programs to rust based programs. There were some hiccups in making it all work together, but in the end, my new setup is :

Alacritty as my terminal emulator
Starship as my shell prompt
nushell as my shell
zellij as my terminal multiplexer

Note : nushell and zellij both are still in their beta versions, and have few known issues, so if you want an absolutely reliable env, use bash/fish/zsh for shell and screen/tmux for terminal multiplexer.

Original setup

Before changing this, I had already installed Alacritty and starship and had used it for few days before switching back to default gnome terminal emulator with starship. The main reason I switched back was that a lot of times I ran multiple processes in parallel, such as running react frontend and node backend. I was used to doing this using the tabs of gnome emulator, and as Alacritty has clearly specified in its Readme, it has no intention of adding a terminal multiplexer, and users would need to use an external one such as tmux to do that (Which makes sense).

Unfortunately, I didn't want to install and setup another program to make it work, and I needed the functionality of multiplexed terminals in single window, rather than opening a new window each time ; which is why I moved back to gnome terminal emulator. In this, I kept starship, as I really liked it, and it was quite useful.

A second look

I had checked out nushell about a year ago, and it seemed very interesting, but then I felt it was a little too complex, and I felt like I wouldn't need all the features it provides, so I didn't try using it.

Few days back, I came across this retweeted by official Rust twitter account, which explained how zellij, a rust terminal workspace solved some of the performance issues. (It is really well writter, do check it out!)

While checking out zellij, I remembered nushell, and went back to its site to check that out as well. This time it didn't felt as complex, as well as its features looked awesome (you can "preview" an image in the terminal itself 😲 😲 ).

With this, I decided to convert all my terminal setup to Rust.

Upgrading

I had already installed alacritty as per their installation guide, as well as had starship set up. Now I had to install and setup nushell and zellij.

Installation process was quite straightforward, using cargo, and for nushell I had to install some other libraries for extra features using apt-get, but it went smoothly following the instructions on their pages :

After the installation, it was time to set it all up together, where I hit a couple of issues. First, I wanted to integrate zellij with alacritty and nushell, so that it can manage multiple sessions.

Initially I though setting the startup command in nushell to zellij would work, as startup command are run at start of each shell session. But quickly I found out I was wrong, as after starting nushell, it would first run zellij, which would keep running with default bash shell, and thus nushell would not actually run until I quit zellij.

Then I found out that zellij can be launched with specific shell as an argument, and alacritty has an option to choose which shell to run in its configuration, which was great because I didn't want to change system default shell to nu (its still in beta).

So first, I copied default alacritty.yml to my home directory. The default file comes when installing from source, or else can be copied from their github repository. It has an option somewhere in the middle for shell :

# Shell
#
# You can set `shell.program` to the path of your favorite shell, e.g.
# `/bin/fish`. Entries in `shell.args` are passed unmodified as arguments to the
# shell.
#
# Default:
#   - (macOS) /bin/bash --login
#   - (Linux/BSD) user login shell
#   - (Windows) powershell
#shell:
#  program: /bin/bash
#  args:
#    - --login

It is commented by default. I thought uncommenting and changing it to zellij , and passing the option to set shell to nushell would work, so I set it to :

shell:
  program: ~/.cargo/bin/zellij
  args:
    - options --default-shell nu

Which ... didn't work. Whenever I would launch alacritty, and it would immediately close, with no error message. I tried opening it from commandline of gnome shell, but it didn't leave any error message there, and that lead me to go through its github issues, and find how to make it generate debug dump, which I though would be helpful to find what is the issue, ... but it didn't work either 😅 😄

After that I figured that it might be possible that it might be because I was giving all the arguments to it in a single arg. Usually when we give args, program gets them as array of strings, and then it can parse it, and [I think] shell splits it by space to form the array. But in this, all was in a single arg entry, and thus was getting sent to program (zellij) as single argument, instead of 'options' , '--default-shell' and 'nu' being separate args.

After figuring this out, I separated them as individual args, and finally my config looks as :

shell:
  program: ~/.cargo/bin/zellij
  args:
    - options
    - --default-shell
    - nu

and viola! It worked. Now I had to only set starship as shell prompt which was easy, as nushell has that as an example. And my terminal setup was ready and oxidized. 🎉 🎉 🎉

Now it looks like :

So, did you find this interesting or helpful?
Did you already used any of these , or thinking of trying them out?
Let me know in the comments!

Thank you!

How to create a new react npm package?

YJDoc2 — Mon, 12 Jul 2021 11:25:58 +0000

Hello, I want to create a new component package for react, which I might publish on npm later. I haven't done this before,so can you tell me the steps needed to setup a basic template for a new package, something like what create-react-app does, but for packages. Also most packages on npm have typscript types along with them, so would that require some extra setup steps? Please comment if you have any idea.

Thank you!

Computer Networks, Made interactive

YJDoc2 — Thu, 01 Jul 2021 07:41:17 +0000

Hey!
The short version is : We made a network simulator, where you can setup a network structure, decide packet processing function for each node which is in JS, as well as their memory which is a JS object, and then see in animation how with given packets routing and processing will be done. It is live at https://yjdoc2.github.io/Network-Simulator/, and as you can save and load them in json format, we have already made couple of examples to see, which are at https://github.com/YJDoc2/Network-Simulator/ in examples directory. Please give it a star if you found this interesting, and let me know your thoughts on this in the comments.

Off we go to the longer version!

What is this?

This is a simple network simulator, which has one task : to run the processing function for each packet in queue of each node, then animate the packet forwarding according to the packets returned by the function. Other than the format of return value of the function, there is no restrictions : you can use any valid JS function as the node function to process packets, and each node has a memory, which you ca interact with, and it is a JS object. These simulations can be stored in local storage and loaded from there, or exported and loaded from a JSON file. You can run the simulation step by step, checking memory and queues at each step, or just let the animation play out.

The Goal

When we started this, we had a simple reason behind this : when we were learning computer networks, it had many concepts such as routers, link layer, data layer etc. When learning we would learn why these things were, and how they were supposed to work, but there was no way we could actually interact with these : There is no way we could easily do router programming to implement routing algorithms, unless someone was ready to invest in a router, along with setting up the network and letting students play with it, and we could not actually see how link layer or data layer interacts with packet unless we could go deep in kernel and networking stack programming.

We wanted to make something were people can do all of these, with relative ease. Then I came across this video from computerphile, which described building a virtual switching network in a computer using VMs. But this was still complex to setup, and required installation of things. But using the virtual network as starting point, we developed the idea of network emulator.

As we thought more and more, on this we figured this could be more than just a simple website for simulating networks. This could be used as a learning tool by students and teachers, where teachers can create simulations, export them as JSON, and students could run them, learn from them, and modify them.

This could allow students to not only see the existing algorithms in action as the packets are animated moving from one node to another, and can be color marked to trace them through nodes ; but also allow them to modify them or develop new algorithms which can be tested easily. This not only can be useful for network, but also for cybersecurity demos : to show Man in Middle attacks, to show how diffie hellman allows securely generating private keys using potentially compromised channels.

Now we can see this in action, get our hands in it and change things to see how it would affect the simulation, and not rely on just imagination to see it.

Demo

That's so much of text ! Lets see some GIF demos :

ARP spoofing

Where node A tried to get address of node B, but Man In Middle (MIM) gives it its own address to read the requests.

Firewall

The firewall blocks requests from blocked IP of node A, but allows node B packets to pass through.

We have these both example's JSON file at our git repo, and are trying to add more examples like diffie hellman

Back to the project

So, then we made the website! It is a frontend-only website, so once loaded, it does not need any network connection. It uses Svelte for frontend, which makes it quite light compared to React, as svelte is a compiler :)

This can save projects in local storage, and load saved projects from there, export them in JSON format. It can give custom colors to enqueued packets, so you can trace that packet, and packets generated due to it. It has a logging functionality, which can allow you to log things.

We are working on improving its usability, as in the starting it can be a bit complicated to navigate, So if you re interested in this, an would like to read a post explaining how to use this, please leave a comment 😄 😄

This is hosted using github pages at https://yjdoc2.github.io/Network-Simulator/, and its repo is at https://github.com/YJDoc2/Network-Simulator.

Also we entered this in the hashnode HarperDB hackethon, so be sure to check that post out too : https://vatsal13.hashnode.dev/network-simulator-in-svelte

And Finally

This was out first project using svelte, also first time using Vis JS and SVG JS. We faced some problems combining them, but it was interesting ;) But this post is long as it is ; so, if you would like to know our experience about working with them, please leave a comment telling what would you like to know, and I'll make a post about it. 😉

Please go and checkout the project, make sure to star it on github, and leave a comment here to let us know what you think about the project 😄

Thanks!