Dev's blog

Mitosis: Write Once, Run Everywhere 🌐

Divyansh Mehta — Wed, 08 May 2024 19:23:24 GMT

What is Mitosis?

Mitosis is an open-source project by Builder.io that provides a unified development experience across different frontend frameworks. Here’s what it offers:

Single Codebase, Multiple Frameworks:
- With Mitosis, you can build your components in a single codebase using a familiar syntax (similar to JSX).
- These components can then be compiled to work seamlessly with various frameworks, eliminating the need to rewrite the same component logic for different platforms.
Supported Frameworks:
- Mitosis compiles your components to native code for the following frameworks:
  - React
  - Vue
  - Angular
  - Svelte
  - Solid
  - Alpine
  - Qwik
  - And more!
Why Use Mitosis?
- Consistent Design System:
  - Imagine maintaining a consistent design system across multiple frameworks. Mitosis makes it possible!
  - You can create your UI components once and reuse them across different projects, regardless of the frontend technology stack.
- Sync Design Systems from Figma to Code:
  - Mitosis allows you to sync your design systems directly from Figma to code.
  - Publish your design tokens (colors, typography, spacing, etc.) to npm, making them accessible across all supported frameworks.
- Avoid Web Component Pitfalls:
  - While web components are powerful, they come with challenges like encapsulation, performance overhead, and limited framework integration.
  - Mitosis compiles your components to native framework code, avoiding these pitfalls.

QuickStart with Mitosis

To create a new Mitosis project from scratch, run the following command:
```
 npm create @builder.io/mitosis@latest
```
This sets up a fresh Mitosis project.
Read the README.md generated in your new project. It explains the project structure and provides a walkthrough on building and testing your components.

Resources

Documentation: Dive deeper into Mitosis by exploring the official documentation.
Playground: Experiment with Mitosis in the interactive playground.
Figma Integration: Learn how to integrate Figma with Mitosis for a seamless design-to-code experience.
Mitosis Discord: Join the Mitosis community on Discord.

Contribute to Mitosis on GitHub

Interested in contributing? Check out the developer docs to get started.
Explore our list of good first issues and become part of the Mitosis journey!

😊 Happy coding!

Day 2/30 - Learning Rust 🦀

Divyansh Mehta — Mon, 04 Mar 2024 16:09:41 GMT

Welcome to Day 2 of our Rust journey! Today, we’ll dive into the fundamental concepts of variables, mutability in Rust. Let’s get started!

Variables and Mutability

1. Declaring Variables

In Rust, you declare variables using the let keyword. Variables are immutable by default, meaning their values cannot be changed once assigned. Here’s an example:

fn main() {
    let name = "Alice"; // Immutable variable
    println!("Hello, {}!", name);
}

2. Mutability

To create mutable variables, use the mut keyword:

fn main() {
    let mut age = 30; // Mutable variable
    age += 1; // Modify the value
    println!("Next year, I'll be {} years old.", age);
}

3. Constants

Constants are declared using theconst keyword and must have a fixed value at compile time.

const PI: f64 = 3.14159;
fn main() {
    println!("The value of PI is approximately {}.", PI);
}

Points to remember about rust variables:

By default, Rust variables are immutable.
If you try to reassign the values to variables,. If they are declared like this: let x = 5; then you will encounter an error like this:cannot assign twice to immutable variable x.
Although variables are immutable by default, you can make them mutable by adding mut in front of the variable name.
mutcannot be used in conjunction with constants. Not only are constants immutable by default, but they are immutable at all times. const declarations need the type of the value to be annotated, like:u32, and you use it instead of the let keyword.
Rust’s naming convention for constants is to use all uppercase with underscores between words. Ex: THREE_HOURS_IN_SECONDS

Shadowing

Shadowing means that it is possible to declare a new variable with the same name as an existing one. According to Rustaceans, when you use the variable name, the compiler will see the second variable since the first variable is shadowed by the second.

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

// Output
// The value of x in the inner scope is: 12
// The value of x is: 6

Another distinction between mut and shadowing is that when we use the let keyword again, we're essentially establishing a new variable, so we can modify the value's type while keeping its name the same.

    let spaces = "   ";
    let spaces = spaces.len();

There are two types of space variables: a numeric type for the second and a string type for the first. Because of shadowing, we can reuse the more straightforward spaces namess rather than having to think of new ones, like spaces_str and spaces_num . However, as demonstrated here, if we attempt to utilize mut for this, we will receive a compile-time error:

    let mut spaces = "   ";
    spaces = spaces.len();

The error says we’re not allowed to mutate a variable’s type.

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
2 |     let mut spaces = "   ";
  |                      ----- expected due to this value
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` due to previous error

Stay tuned for Day 3, where we’ll explore datatypes and functions. Happy coding! 🦀🚀

Day 1/30 - Learning Rust 🦀

Divyansh Mehta — Sun, 03 Mar 2024 09:08:45 GMT

Introducing the 30-Day Rust Coding Challenge! 🦀 This challenge will go into the realm of Rust programming. We shall choose a topic related to Rusts every day and thoroughly study it. The official Rust documentation will cover every single topic that we will study throughout this challenge.

Today's topics explored include:

Rust Installation
Rust First Program (Namaste, Rust!!!)
How to build projects with Cargo

1. Rust Installation

Before diving into Rust, let’s set up our development environment. Follow these steps to install Rust:

Windows:
- Visit the official Rust website.
- Download the installer and run it.
- Follow the installation instructions.
Linux/macOS:
- Open your terminal.
- Run the following command:
```
  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
- Follow the prompts to complete the installation.
Verify the installation by running:
```
 rustc --version
```

💡

A local copy of the documentation is also included with the Rust installation so you may read it offline. To access the local documentation in your browser, run command: rustup doc

😊

You can update your Rust current version to latest version without downloading it again: $ rustup update

🥲

You can also uninstall Rust too: $ rustup self uninstall

2. Rust First Program (Namaste, Rust!!!)

Let’s create a simple “Namaste, Rust!” program. Open your favorite text editor (VS Code 😅) or IDE and create a new file named hello.rs. Add the following code:

// hello.rs
fn main() {
    println!("Namaste, Rust!");
}

Save the file and open your terminal. Navigate to the directory where hello.rs is located and run:

rustc hello.rs
./hello

You should see the output: Hello, World!

Rust macro