For example when you assign the return value of a function to a variable but you don't explicitely write the type of the variable, Rust will derive (deduct) the type based on the function signature.

If you declare a variable let x = 2;, Rust will derived that it is an i32 and the inlay type hints will show let x: i32 = 2;.

In another case if add together two variables holding numbers (that default to i32) and declare the resulting variable to be i8 then Rust will derived that the original two variables also must be i8.

So

    let x = 2;
    let y = 3;

is understood as

    let x: i32 = 2;
    let y: i32 = 3;

but

    let x = 2;
    let y = 3;
    let z: i8 = x +y;

is understood as

    let x: i8 = 2;
    let y: i8 = 3;
    let z: i8 = x +y;

The inlay type hints will help you understand this.

Inline (inlay) type hints:

I configured the following to make it work. I am not sure everything is really needed.

• Installed rust-analyzers

rustup component add rust-analyzer

• settings.json

In the settings.json file I added the following:

  "inlay_hints": {
    "enabled": true,
  },
  "enable_language_server": true,
  "lsp": {
    "rust-analyzer": {
      "binary": {
        "path": "/home/gabor/.cargo/bin/rust-analyzer"
      },
      "initialization_options": {
        "inlayHints": {
          "maxLength": null,
          "lifetimeElisionHints": {
            "enable": "always",
            "useParameterNames": true,
          },
          "closureReturnTypeHints": {
            "enable": "always",
          },
        },
      },
    },
  },

• Trusted code

Opened the crate I was working on as a "project" and then in the top-left corner of the IDE I clicked on "Trusted project".

Then I could also use Crtl-: to toggle the inline hint.

For example the date and time when it was compiled.

Cargo.toml

We need to add the built crate as a build-time dependency.

examples/embed-build-time-data/Cargo.toml

[package]
name = "embed-build-time-data"
version = "0.1.0"
edition = "2024"

[dependencies]

[build-dependencies]
built = { version = "0.8", features = ["cargo-lock", "dependency-tree", "chrono", "git2", "semver"] }

build.rs

We need to create build.rs in the root of the crate.

examples/embed-build-time-data/build.rs

fn main() {
    built::write_built_file().expect("Failed to acquire build-time information")
}

main.rs

We can then access the data in our code during run-time.

examples/embed-build-time-data/src/main.rs

mod built_info {
    include!(concat!(env!("OUT_DIR"), "/built.rs"));
}

fn main() {
    println!("TARGET                {:?}", built_info::TARGET);
    println!("PKG_VERSION           {:?}", built_info::PKG_VERSION);
    println!("RUSTC_VERSION         {:?}", built_info::RUSTC_VERSION);

    println!("GIT_VERSION           {:?}", built_info::GIT_VERSION);
    println!("GIT_DIRTY             {:?}", built_info::GIT_DIRTY);
    println!("GIT_COMMIT_HASH       {:?}", built_info::GIT_COMMIT_HASH);
    println!(
        "GIT_COMMIT_HASH_SHORT {:?}",
        built_info::GIT_COMMIT_HASH_SHORT
    );

    println!("BUILT_TIME_UTC        {:?}", built_info::BUILT_TIME_UTC);

    println!("CI_PLATFORM           {:?}", built_info::CI_PLATFORM);
}

Output

$cargo run

TARGET                "x86_64-unknown-linux-gnu"
PKG_VERSION           "0.1.0"
RUSTC_VERSION         "rustc 1.93.0 (254b59607 2026-01-19)"
GIT_VERSION           Some("9c6447a")
GIT_DIRTY             Some(true)
GIT_COMMIT_HASH       Some("9c6447a01046142ccf471a597f21d2c08c67c2cd")
GIT_COMMIT_HASH_SHORT Some("9c6447a")
BUILT_TIME_UTC        "Fri, 6 Feb 2026 10:42:50 +0000"
CI_PLATFORM           None

• 00:00 Introduction
• 00:30 Open source contributors are volunteers
• 01:15 How to select an open source project to contribute to?
• 03:30 Select a recently updated project on GitHub.
• 05:08 Rust Digger
• 06:33 A crate that has no repository link... and one that has.
• 09:40 Check the previous Pull-Request adding the repository field to dvb
• 11:05 Picking the spyne-syntax crate.
• 12:40 The GitHub account of Zaid Ahmed, finding the repository of spyne-syntax
• 15:45 Making the change to Cargo.toml, fork the repository
• 17:55 Commit the change, decide on the commit message.
• 20:50 Explain the change on the trailing line.
• 21:50 The issue where I collect the PRs.
• 25:00 We finished the Pull-Request.
• 25:10 Some PRs take time to get accepted.
• 27:40 Offering driver-navigator pair-programming.
• 29:05 Radek: Is there some automatic evaluation of the PR?
• 30:00 GitHub Actions, tests, co-pilot integration.
• 34:45 Karol is volunteering to do a PR.
• 35:50 Karol start sharing his screen.
• 36:54 Picking the kftray-helper crate to work on.
• 38:50 A repository with multiple creates.
• 46:05 CodeRabbit skipped the review.
• 46:30 Google CLA - The legal issues.
• 51:10 Baby steps! Chat with us

1. The user types in an email address (and some other date)
2. The system checks that the looks ok, including the format of the email address. (e.g. that it is not empty)
3. Then it generates a unique code and stores all the received data and the unique code in the database.
4. Then it send an email to the given address containing a URL with the unique code.
5. When the user receives the email and clicks on the link the web system receives this verification request and can update the records marking the email as verified.

There can and probably should be a number of extra things in the process.

• For example the database should contain an expiration date for the code.

The question though, how do you test this code? Do you let the system send out real emails on every run? That would be slow and the test would need to rely an external service that will receive the email from where the test can download it for verification.

One solution for this is to save the email message in a file during the tests and make the tests read that file.

This is what you can see in this similified example.

Cargo.toml

examples/testing-email-sending/Cargo.toml

[package]
name = "mail-sender"
version = "0.1.0"
edition = "2024"

[dependencies]
anyhow = "1.0.100"
clap = { version = "4.5.53", features = ["derive"] }
lettre = { version = "0.11.19", features = ["file-transport", "sendmail-transport"] }
uuid = "1.19.0"

main.rs

examples/testing-email-sending/src/main.rs

use clap::Parser;
use lettre::{FileTransport, Message, SendmailTransport, Transport, message::header::ContentType};

#[derive(Parser)]
struct Cli {
    #[arg(long)]
    from: String,

    #[arg(long)]
    to: String,
}

fn main() {
    let args = Cli::parse();

    // We get this from the command line.
    // In a real application it would come from a config file.
    let from = &args.from;

    // This is what the user entered when registering.
    let user_email = args.to.clone();

    register(from, &user_email);
}

fn register(admin_email: &str, user_email: &str) -> String {
    // This code is saved to the database and emailed to the user.
    let code = uuid::Uuid::new_v4().to_string();

    let subject = String::from("Email sent to confirm registration");
    let body = format!("Welcome! Use this code {code} to verify your email address.");

    let email = Message::builder()
        .from(admin_email.parse().unwrap())
        .to(user_email.parse().unwrap())
        .subject(subject)
        .header(ContentType::TEXT_PLAIN)
        .body(body)
        .unwrap();

    if cfg!(test) {
        let dirname = ".";
        let sender = FileTransport::new(dirname);
        let filename = sender.send(&email).unwrap();
        format!("{filename}.eml")
    } else {
        println!("Sending email to {}", user_email);
        let sender = SendmailTransport::new();
        sender.send(&email).unwrap();
        String::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_register_creates_valid_email() {
        let filename = register("admin@example.com", "user@example.com");
        let content = std::fs::read_to_string(filename).unwrap();

        assert!(content.contains("From: admin@example.com"));
        assert!(content.contains("To: user@example.com"));
        assert!(content.contains("Subject: Email sent to confirm registration"));
        assert!(content.contains("Welcome! Use this code"));

        let code_start =
            content.find("Welcome! Use this code ").unwrap() + "Welcome! Use this code ".len();
        let code_end = content.find(" to verify your").unwrap();
        let _code = &content[code_start..code_end];

        // We can then use the code to verify the user in the test.
    }
}

Config test

We can either use

#[cfg(test)]

and

#[cfg(not(test))]

or we can use

if cfg!(test) {
    ...
} else {
    ...
}

examples/mail-sender/Cargo.toml

[package]
name = "mail-sender"
version = "0.1.0"
edition = "2024"

[dependencies]
anyhow = "1.0.100"
clap = { version = "4.5.53", features = ["derive"] }
lettre = { version = "0.11.19", features = ["file-transport", "sendmail-transport"] }

examples/mail-sender/src/main.rs

use clap::Parser;
use lettre::{FileTransport, Message, SendmailTransport, Transport, message::header::ContentType};
use std::io::Read;

#[derive(Parser)]
struct Cli {
    #[arg(long)]
    from: String,

    #[arg(long)]
    to: String,

    #[arg(long)]
    subject: String,

    #[arg(long)]
    dir: Option<String>,
}

fn main() {
    let args = Cli::parse();
    let mut body = String::new();
    std::io::stdin().read_to_string(&mut body).unwrap();

    let email = Message::builder()
        .from(args.from.parse().unwrap())
        .to(args.to.parse().unwrap())
        .subject(args.subject)
        .header(ContentType::TEXT_PLAIN)
        .body(body)
        .unwrap();

    match args.dir {
        Some(dirname) => {
            let sender = FileTransport::new(dirname);
            let filename = sender.send(&email).unwrap();
            println!("{filename}.eml");
        }
        None => {
            let sender = SendmailTransport::new();
            sender.send(&email).unwrap();
        }
    }
}

[package]
name = "hash-password"
version = "0.1.0"
edition = "2024"

[dependencies]
argon2 = { version = "0.5.3", features = ["std"] }

examples/hash-password/src/main.rs

use argon2::{
    Argon2,
    password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString, rand_core::OsRng},
};
use std::io::{self, Write};

fn main() {
    // Get password from user input
    print!("Enter password to hash: ");
    io::stdout().flush().unwrap();

    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let password = input.trim().as_bytes();

    // Generate a random salt
    let salt = SaltString::generate(&mut OsRng);

    // Initialize Argon2 with default configuration
    let argon2 = Argon2::default();

    // Hash the password
    let password_hash = argon2.hash_password(password, &salt).unwrap();

    println!("\nPassword hash: {}", password_hash);

    // Demonstrate verification
    println!("\nVerifying the password...");
    let hash_string = password_hash.to_string();
    println!("\nPassword hash: {}", hash_string);
    let parsed_hash = PasswordHash::new(&hash_string).unwrap();

    match argon2.verify_password(password, &parsed_hash) {
        Ok(_) => println!("✓ Password verification successful!"),
        Err(_) => println!("✗ Password verification failed!"),
    }
}

This is nice as you won't need to worry about updating it, but it has the obvious disadvantage that the rust compiler automatically changes without you making any change in the configuration.

Many projects use the actions-rs/toolchain, but it has been deprecated on October 13, 2023.

Many use dtolnay/rust-toolchain to set the toolchain(s) explicitely. You can either set a specific version number or you can use the words: stable for the most recent stable version, beta for the next version, nightly for wilde development efforts.

examples/github-workflows/matrix.yml

name: Matrix
on:
  - pull_request
  - push
jobs:
  main:
    strategy:
      matrix:
        rust:
          - stable
          - beta
          - nightly
          - 1.78
          - 1.88
    name: ${{matrix.rust}}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@v1
        with:
          toolchain: ${{matrix.rust}}
          components: rustfmt, clippy
      - run: rustup --version
      - run: rustc -vV

      - run: cargo clippy -- --deny clippy::pedantic
      - run: cargo fmt --all -- --check
      - run: cargo test
        #      - run: cargo install cargo-tarpaulin && cargo tarpaulin --out Xml
        #      - uses: codecov/codecov-action@v1

GitHub Actions

Popular GitHub Actions used by Rust Crates.

• dtolnay/rust-toolchain to install the right toolchain(s), target(s), and component(s).

• bnjbvr/cargo-machete to remove unused Rust dependencies

• Swatinem/rust-cache smart caching for rust/cargo projects with sensible defaults to reduce compilation time.

Cargo commands

Various cargo commands I saw in the GitHub Workflows

cargo build --verbose

cargo test --verbose

cargo fmt
cargo fmt -- --check
cargo fmt -- --all --check

cargo clippy
cargo clippy -- --deny clippy::pedantic
cargo clippy --all-targets ${{ matrix.feature }} -- -D warnings
    // where the matrix.feature field can be ['', '--no-default-features', '--all-features']

cargo doc --no-deps --all-features

GitHub Workflow elements

env:
  CARGO_TERM_COLOR: always

Caching with the generic cache action

Using actions/cache (but see the rust-cachec above)

      - name: Cache cargo registry
        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-cargo-

Verify git tag matches Cargo.toml version

      - name: Verify tag matches Cargo.toml version
        run: |
          TAG_VERSION=${GITHUB_REF#refs/tags/v}
          CARGO_VERSION=$(grep '^version = ' Cargo.toml | sed 's/version = "\(.*\)"/\1/')
          echo "Tag version: $TAG_VERSION"
          echo "Cargo.toml version: $CARGO_VERSION"
          if [ "$TAG_VERSION" != "$CARGO_VERSION" ]; then
            echo "Error: Tag version ($TAG_VERSION) does not match Cargo.toml version ($CARGO_VERSION)"
            exit 1
          fi

Publish to crates.io

      - name: Publish to crates.io
        run: cargo publish
        env:
          CARGO_REGISTRY_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}

Rust en Castellano, en todo de mundo:

• Rust Lang En Español

• GitHub: RustLang en Español - Comunidad de Rustlang en Español
• LinkedIn company: Comunidad de RustLang en Español
• LinkedIn group: RustLang en Español
• Telegram: Programación Rust
• Reddit: r/rustlanges
• Instagram: rustlanges
• X/Twitter
• Mastodon
• YouTube: RustLang en Español
• Twitch: RustLangES

Libros

• El Lenguaje de Programación Rust
• Comprehensive Rust
• Rust en Embedidos
• Rust para C#/.NET Developers
• Rust para Go Developers

Grupos de Meetup

• Busca para los paises hispanohablantes

Argentina

• Rust Argentina (1,135 members) - Buenos Aires

Australia

• Rust Melbourne (1,170 members) - Melbourne

• Rust Sydney (934 members) - Sydney

• Rust Brisbane (450 members) - Brisbane

• Rust Perth Meetup Group (128 members) - Perth

• Canberra Rust User Group (109 members) - Canberra

Austria

• Rust Linz (1,176 members) - Linz

• Rust Vienna (619 members) - Vienna

Belgium

• Belgium Rust user group (238 members) - Brussels

Brazil

• Rust São Paulo Meetup (1,314 members) - São Paulo

• Rust Rio (109 members) - Rio de Janeiro

Canada

AB

• Calgary Rust (30 members) - Calgary

BC

• Vancouver Rust (1,351 members) - Vancouver

ON

• Rust Toronto (648 members) - Toronto
• Rust KW (315 members) - Kitchener

QC

• Rust Montréal (335 members) - Montréal

China

• WebAssembly and Rust Meetup (Wasm Empowering AI) (421 members) - Beijing

• Chengdu (0 members) - Chengdu

Colombia

• Rust Medellin (318 members) - Medellin

• Rust Colombia (155 members) - Medellín

Croatia

• impl Zagreb for Rust (226 members) - Zagreb

Czech Republic

• Rust Prague (448 members) - Prague

• Rust Czech Republic (260 members) - Prague

• Rust Moravia (98 members) - Olomouc

Denmark

• Copenhagen Rust Community (865 members) - Copenhagen

• Rust Aarhus (467 members) - Aarhus

France

• Rust Paris (1,799 members) - Paris

• Montpellier Rust Meetup (315 members) - Montpellier

• Rust Lyon (315 members) - Lyon

• Rust Lille (299 members) - Lille

Georgia

• Rust Tbilisi (151 members) - Tbilisi

Germany

• Rust Berlin (3,435 members) - Berlin

• Rust Munich (1,546 members) - München

• Rust Nuremberg (967 members) - Nürnberg

• Rust Cologne (796 members) - Köln

• Rust Meetup Hamburg (763 members) - Hamburg

• Rust Rhein-Main (296 members) - Darmstadt

• Rust Hack & Learn Karlsruhe (233 members) - Karlsruhe

• Rust - Modern Systems Programming in Leipzig (168 members) - Leipzig

• Rust Frankfurt (117 members) - Frankfurt

• Paessler Rust Camp 2024 (62 members) - Nürnbert

India

• Rust India (2,700 members) - Bangalore

• Rust Delhi (web) (1,446 members) - Delhi

• Rust Language Hyderabad (1,106 members) - Hyderabad

• Rust Pune (565 members) - Pune

Indonesia

• Rust Indonesia (0 members) - Jakarta ?

Ireland

• Rust Dublin (1,086 members) - Dublin

Israel

• Rust TLV (web) (1,343 members) - Tel Aviv-Yafo

Italy

• Rust Language Milano (636 members) - Milano

• Rust Roma (425 members) - Roma

Japan

• Tokyo Rust Meetup (801 members) - Tokyo

Lithuania

• Vilnius Rust and Go Meetup Group (292 members) - Vilnius

Malaysia

• Rust Malaysia (0 members) - Kuala Lumpur

Mexico

• Rust MX (1,192 members) - México City

• Rust Lang Comunidad Mexico (107 members) - Guadalajara

Netherlands

• Rust Nederland (1,883 members) - Amsterdam

• Rust, Getting Started (87 members) - Tiel

• Dutch Rust Meetup (74 members) - Enschede

New Zealand

• Rust Wellington (304 members) - Wellington

• Christchurch Rust Meetup Group (179 members) - Christchurch

Nigeria

• Rust Nigeria (448 members) - Lagos

Norway

• Rust Oslo (1,059 members) - Oslo

• Rust Trondheim (143 members) - Trondheim

Peru

• Perú Rust User Group (58 members) - Lima

Poland

• Rust Wroclaw (887 members) - Wroclaw

• Rust Warsaw (668 members) - Warsaw

• Rust Gdansk (271 members) - Gdansk

• Rust Poland (17 members) - Poznan

Russia

• Rust Moscow (1,519 members) - Moscow

Serbia

• Belgrade Rust Meetup Froup (140 members) - Belgrade

Singapore

• Rust Singapore (309 members) - Singapore

Slovakia

• Bratislava Rust Meetup Group (191 members) - Bratislava

South Africa

• Johannesburg Rust Meetup (953 members) - Johannesburg

South Korea

• Rust Seoul (70 members) - Seoul

Spain

• BcnRust (890 members) - Barcelona

• MadRust (597 members) - Madrid

Sweden

• Stockholm Rust (1,043 members) - Stockholm

• Rust Sthlm (673 members) - Stockholm

• Rust Göteborg (489 members) - Göteborg

Switzerland

• Rust Zurich (1,141 members) - Zürich

• Rust Basel (303 members) - Basel

• Rust Bern (269 members) - Bern

Taiwan

• Rust Taiwan Community (61 members) - Taipei

USA

AZ

• Desert Rust (301 members) - Phoenix

CA

• Rust Bay Area (2,932 members) - San Francisco
• San Francisco Rust Study Group (601 members) - San Francisco
• Rust Los Angeles (546 members) - Los Angeles
• San Diego Rust (493 members) - San Diego
• Mountain View Rust Meetup (257 members) - Mountain View
• Pasadena Thursday Go / Rust (165 members) - Pasadena
• Rust Silicon Valley Community (135 members) - San Jose

CO

• Rust Denver (860 members) - Denver
• Boulder Rust Meetup (169 members) - Boulder

DC

• Rust DC (979 members) - Washington

GA

• Rust Atlanta (377 members) - Atlanta

IL

• Chicago Rust Meetup (509 members) - Chicago

IN

• Indy Rust (403 members) - Indianapolis

MA

• Boston Rust Meetup (1,321 members) - Boston

MI

• Detroit Rust (187 members) - Detroit

MN

• Minneapolis Rust Meetup (542 members) - Minneapolis

MO

• STL Rust (335 members) - Saint Louis

NY

• Rust NYC (web) (3,523 members) - New York
• Buffalo Rust Meetup (475 members) - Buffalo

OH

• Columbus Rust Society (559 members) - Columbus

OR

• PDXRust (826 members) - Portland

TX

• Dallas Rust User Meetup (937 members) - Dallas
• Rust ATX (674 members) - Austin

UT

• Utah Rust (567 members) - Lehi

VA

• Charlottesville Rust Meetup (584 members) - Charlottesville

WA

• Seattle Rust User Group (1,939 members) - Seattle

• Spokane (78 members) - Spokane

Uganda

• Rust Circle Kampala (53 members) - Online

United Kingdom

• Rust London User Group (3,493 members) - London, 17

• Rust and C++ Cardiff (1,147 members) - Cardiff

• Cambridge Rust meetup (491 members) - Cambridge, C3

• Rust and Friends (457 members) - Edinburgh

• Rust Manchester (415 members) - Manchester

• Women in Rust (285 members) - London

• Oxford Rust Meetup Group (262 members) - Oxford, K2

• Reading Rust Workshop (200 members) - Reading

• Rust Belfast Meetup (127 members) - Belfast, R3

Uruguay

• Rust Meetup Uruguay (453 members) - Montevideo

Worldwide

• RustLang en Español (2,305 members) - Online

For this page even the Markdown file is generated. See the preprocessing in the repository and the examples/meetups.yaml file.

It is also a good (or at least reasonable) measurement of the popularity of the language.

The Rust user groups page was updated exactly 6 months ago so today, December 17 is the day I share the new report.

• The report on 2024.12.17.
• The report on 2024.06.17.

Rust User Groups

There are mostly Meetup groups in the list, though some use different platforms. In some cases the number of members cannot be determined.

Overall:

In the last 6 months several groups closed down. Probably due to the price-hike of Meetup (the new price is 3 times of the old one). Some might use another platform, but I don't know where. If you do, please let me know!

These are the groups that were closed:

• Rust Chennai in Chennai, India. 1,204
• Rust AKL in Auckland, New Zealand. 672
• Finland Rust-lang Group in Helsinki, Finland. 602
• Rust-Saar in Saarbrücken, Germany. 425
• Rust Chinese Community in Beijing, China. 163
• Ottawa Rust Language Meetup in Ottawa, ON, Canada. 154
• Hack-away with Rust in Espoo, Finland. 125
• RustSchool Rotterdam in Rotterdam, Netherlands. 104
• Rust Bordeaux in Bordeaux, France. 95
• Rust Triangle in Durham, NC, USA. 89
• Rust Bristol in Bristol, United Kingdom. 86
• Orange County Rust in Irvine, CA, USA. 72
• TOTAL: 3791

the number of members grew only by 2%, but 3,791 were in the closed groups. If we only count the groups that remained open then the growth is 7%. Less than in the previous 6 months, but still impressive.

• In the previous 6 months the number of members grew by 14%. Thats over 30% annually.
• In the 3 months before that the growth was 4.4% or roughly 20% annually.

The three largest Rust groups are:

• Rust NYC (3,523 members. It had 3,192)
• Rust London User Group (3,493 members. It had 3,357)
• Rust Berlin (4,435 members. It had 3,123).

These are also the only groups with more than 3,000 members.

My Code-Mavens group has 3,841 members (up from 3,213). I use it to organize virtual events in English about Rust, Python, and Perl. I did not include it in the list.

The Rust Tel Aviv group that I organize has 1,343 members (up from 1,011 6 months ago and up from 950 members from when I inherited it).

For full details, see of Rust User Groups.

I updated the figures in several commit that will allow someone to check the changes more easily. Here are the commits.

Rust on LinkedIn

Rust on LinkedIn

Rust on Facebook

The first group listed is inactive, but still people become members.

Full report on Rust on Facebook

Rust on Reddit

Subredit members

All 3 groups grow nicely.

See Rust on Reddit

X Twitter

Counting followers

• Orhun Parmaksız is the maintainer of Ratatui.rs.

• Guillaume Gomez, rustdoc team leader, mdbook contributor, Rust Paris organizer.

Instagram

See Rust on Instagram.

Rust on Telegram

There might be other groups, but I am not aware of them and I've just created the Rust Maven telegram group so let me put it here:

Number of members.

And you are invited to join!

If you know of other groups, let me know so I can list them here.

WhatsApp

Are there any Rust groups on WhatsApp that you would like me to include in my report?

The popularity of Rust

The Stack Overflow survey 2024 indicates that Rust is the most admired language by a large gap at 82.2% (the next is Elixir at 76.8%). That is a lot of people love Rust. However this gap was much bigger last year.

On the other hand it is only 6th most desired language with 28.7%. Ahead of it are SQL and HTML/CSS that are, well, different. Also TypeScript, Python, and JavaScript. As I understand this indicates how many job openings are.

In a nutshell, this seem to indicate that many people will want to use Rust, but the number of open positions are relatively low.

However, being on the 6th place is also extremely good.

PYPL - PopularitY of Programming Language

Indicates that Rust is number 8 with 2.97% share and +0.4% trend (up from 9 with 2.66% share and +0.5% 1-year trend six month ago) (up from number 10 twelve months ago)

Python is number 1 with 30.63% share and 1.1% trend. (was 1 with 29.71% share and 1.5% 1-year trend six month ago)

C/C++ (bundled together) is number 4 with 7.02% with +0.7% trend (was number 4 with 7.06% with 0.3% 1-year trend six month ago). (up from number 5 twelve months ago)

TIOBE

Rust is number 18 (dowm from 14 six month ago) (up from number 18 a year ago) with 1.29% ratings and +0.48% change.

Python is number 1 25.87% +10.48% (was 1 with 23.84% ratings and +9.98% change).

C++ is number 2 10.68%, +0.65% (was 2 with 10.82% ratings and 0.81% change.)

C is number 9.47% +0.24% (was 4 with 9.10% ratings and -2.34% change.)

Java is number 4 8.84% +0.44% (was 3 with 9.72% ratings and 1.73% change).

Also on TIOBE:

• ADA jumped from 25 to 11 in 1 year
• Perl jumped from 17 to 13 in 1 year
• R jumped from 21 to 14 in 1 year

Even if earlier you thought that TIOBE is real this can show you that it has some very serious flaws. I doubt ADA and R would jump that much in a year, but I know that nothing in the Perl world explains this surge in Perl. I think I can say that as I am the editor of the Perl Weekly newsletter so I think I have some undertanding about the popularity of Perl.

• Orhun Parmaksız is the maintainer of Ratatui.rs.

• Guillaume Gomez, rustdoc team leader, mdbook contributor, Rust Paris organizer.

2024.06.19

2024.12.16

2025.06.17

• Guest: Herbert Wolverson Rust Trainer/Consultant at Ardan Labs and Chief Product Officer at LibreQoS.

• Host: Gabor Szabo Rust and Python trainer and consultant.

• Language: English

• Location: Zoom

Trying to understand how people use Rust at their companies.

Planned events

Previous recordings

Process

• We schedule an event (in the Code-Mavens Meetup group) and let anyone register and attend the online event.

• During the event the audience can ask questions in the chat room that can enhance the whole conversation.

Topics

(not all of them might be relevant to you, and we might cover more.)

• Please introduce yourself.

• Please introduce the company you work for. The products and services of your company.

• What was your entry point to Rust?

• Why do you use Rust?

• How did you introduce Rust to this company?

• Are you porting some software from some other language?

  • Why?
  • From which language?
  • What is the process?

• Are you writing a greenfield process in Rust?

  • What were the alternatives?
  • Why did you pick Rust?

• How do you select your dependencies?

  • Do you have a well defined process maybe even a selected team to accept new dependencies or is it up to the individual developer to add a new dependency?

• How much can you rely on open source crates?

  • How do you interact with the wider Rust community?
  • How do you ensure that the crates you rely on directly and all their dependencies are secure and well maintained?

• How do you fix issue in dependencies?

  • Locally?
  • Is it easy to have your changes accepted upstream?

• Do you allocate time to your developers to contribute to open source projects?

• Have you experienced with sponsoring certain open source Rust (or other) developers or bug bounties?

• What is your branching and development process?

  • Branches and pull-request?
  • Code-reviews?
  • Pair-programming?

• Are you looking for Rust developers? What is the hiring process?

• Is it easy/difficult to find Rust developers?

• What can people do to increase their chances to get picked and maybe even hired by your company?

• Time-travel: What would be the answer if someone has the time to plan 1-2 years ahead?

• What would you recommend to other engineering decision makers, CTOs, VP R&Ds, VP of Engineering, tech founders, etc. how to evaluate the feasibility of Rust for their projects and goals?

• How to adopt rust?

• What is the ROI switching to rust? How can we measure it?

• How do you evaluate the decision to switch to / use Rust?

• What are the parts of the Rust ecosystem that you found less than perfect? What do you miss from the language or from the ecosystem?

• What is your experience using AI tools to write Rust code? How do you think will impact the market share of programming languages?

• Guests: Eli Shalom & Igal Tabachnik of Eureka Labs
• Host: Gabor Szabo
• Language: English
• Location: Zoom

In this episode, we explore how Rust is powering infrastructure at Eureka Labs - a blockchain company operating in a low-latency, high-throughput environment.

Eureka Labs is pioneering next-generation block building on Ethereum. Their work focuses on advancing the logic of block construction to support more efficient execution and expand the functionality that can be packed into each block’s limited timeframe.

Eli and Igal will discuss how Rust has been instrumental in developing their high-performance block builder. Before founding Eureka, the team tackled large-scale engineering and algorithmic problems across industries.

If you have questions to Eli and Igal, please send it to Gabor Szabo

1. Concepts from functional languages: immutability, green/virtual threads (tokio), lambdas, iterators, type classes (derive)

2. Libraries: Clap (CLI parser), Reth (Ethereum protocol implemented in Rust)

3. Inspirations: Grayden Hoare's async/await retrospective, "Constraints Liberate, Liberties Constrain" talk by Runar Bjarnason.

4. Learning Rust: The Rust Book Live coding streams by Jon Gjengset "Rust for Rustaceans" book by Jon Gjengset.

5. AI tools: Claude Code, Amp by Sourcegraph

Transcript

1 00:00:02.390 --> 00:00:19.680 Gabor Szabo: Hello and welcome to the code. Meet Maven meeting and podcast on the raw station. If you're listening to us, this is going to be a live recording, meaning that there are going to be. There are a few guests beyond or guest speakers.

2 00:00:19.690 --> 00:00:33.920 Gabor Szabo: There are a few guests who listen and can ask questions in the chat room. They can't speak, because that's only the 3 of us. And but those people who are present here, you're welcome to ask questions there.

3 00:00:35.060 --> 00:00:47.139 Gabor Szabo: Welcome, Ellie and Igal. So our guest this time is Ali Shalom, the CEO of Euray collapse, and Igal Tabachnik right.

4 00:00:47.140 --> 00:00:48.369 Igal Tabachnik: That's exactly right.

5 00:00:48.920 --> 00:00:51.712 Gabor Szabo: Okay, senior developer and

6 00:00:52.670 --> 00:01:17.559 Gabor Szabo: we are going to talk about your your company and rust, and how you use rust. So I think the 1st thing that I mean the 1st thing I think I should just say myself that I my name is Gabor Sabo, and I'm helping companies with rust and python, and then that's about me, that's enough. And now please introduce yourself. Let's start with Ellie, and then Igar, and please let's see.

7 00:01:18.010 --> 00:01:41.370 Eli Shalom: So thank you very much, Gabo, for inviting us to this. Podcast and even though you gave me the credits for being the CEO and the CTO. And we have another person as the CEO of the company, and my background is very technological. I come from. I spent most of my career in engineering roles. I did a lot of languages and not rust, and started from

8 00:01:41.550 --> 00:01:58.149 Eli Shalom: things like C sharp and C plus plus, and ended as a python developer, mostly for data science purposes and a lot of my career I did in analyzing code. I work for companies who analyze code both for quality and for security. So

9 00:01:58.310 --> 00:02:12.739 Eli Shalom: code and coding languages are a very great passion of mine, and the way we get to rust is very different from code analysis, and we'll get to it today. But it's a great passion of me and most of the people in the in the R. And D.

10 00:02:15.480 --> 00:02:16.260 Igal Tabachnik: Great.

11 00:02:16.370 --> 00:02:36.870 Igal Tabachnik: And I'll introduce myself. So also thank you very much for inviting us to the podcast so my name is Igal Tapachnik. I'm a software developer. And I've also had an interesting career spanning from beginning being Anet developer. And Ellie and I worked together many years ago in another company.

12 00:02:37.400 --> 00:03:06.440 Igal Tabachnik: and we reconnected recently. And we'll talk about that in a bit. So I spent sometimes also working in the area of code tools and developer tools. So building tools for developers which requires a very specialized set of skills. But in the recent years I've switched careers and worked primarily as a backend engineer in companies that primarily work on the Jvm. So my background in the last.

13 00:03:06.650 --> 00:03:17.700 Igal Tabachnik: I want to say, 8 or 9 years was doing backend on Scala the language. So my my journey to rust is also a bit

14 00:03:17.910 --> 00:03:20.130 Igal Tabachnik: different from maybe

15 00:03:20.260 --> 00:03:30.489 Igal Tabachnik: that of other people who come from maybe C plus plus background to rust. I come from more of a functional language, and we'll talk about that. Shortly

16 00:03:30.650 --> 00:03:51.360 Igal Tabachnik: and recently Ellie and I met and I joined Eureka. It didn't have to. It didn't, didn't take a lot to convince me to join Eureka primarily, because I knew that we're going to be developing in rust. And this is something I wanted to try. And the product itself is actually very interesting. And we'll talk about that in a bit.

17 00:03:52.510 --> 00:03:57.539 Gabor Szabo: Yeah. So as I understand, I mean, I I actually also work with Ellie. I'm not in

18 00:03:57.850 --> 00:04:00.480 Gabor Szabo: with him, but in the same company a couple of years ago.

19 00:04:00.920 --> 00:04:03.350 Gabor Szabo: so we know each other from there.

20 00:04:04.349 --> 00:04:17.759 Gabor Szabo: But I really would like to to hear a little bit more about the company. I mean, we haven't yet, so please enjoy what I know so far is it's a very young company. It's only exist a couple of months right.

21 00:04:18.680 --> 00:04:30.190 Eli Shalom: Yeah. So in fact, we started working on on founding Eureka last year. We started with a very open goal like to improve

22 00:04:30.220 --> 00:04:39.380 Eli Shalom: something in crypto or in blockchain, as a technology in general. And we are looking for a lot of areas where there are challenges which are both

23 00:04:39.410 --> 00:04:51.440 Eli Shalom: interesting in the technological aspect of them, and most importantly, to convince the investors that it's worth coming to the company to have something with real essence, something where where there's enough money

24 00:04:51.440 --> 00:05:10.680 Eli Shalom: today to work in. The reason I'm mentioning it is that a lot of companies in the blockchain deal with a greater challenge where they have to aim for the market, which will be there in a few years, and they have to speculate. And it's harder. And what we're working on is something which is active today there is a lot of

25 00:05:10.710 --> 00:05:34.230 Eli Shalom: activity both in terms of traffic and in money. And this is where we are. So what Eureka is doing is we're building a new block builder for ethereum networks. And so one of the things I'm going to do is to give a little bit of explanations, and I'm more than willing to accept questions. Gabble on anything around it.

26 00:05:34.480 --> 00:06:02.489 Gabor Szabo: Yeah. So I should play here the devil's advocate, I think and say that I don't know anything about this, and please explain. But it will be quite easy for me, because I really don't know anything about blockchain, so I will. So please also consider. I mean, I'm quite sure that in the audience here, and then later on, in the podcast there are going to be people who are experts in blockchain. But I'm also going to be a lot of people who don't know anything about it. So

27 00:06:02.790 --> 00:06:19.400 Gabor Szabo: as we go, please also explain a little bit about it. Do I understand correctly that actually, you started the company without having any specific product or service in mind. Just you want to say, Okay, improve something in the area of blockchain.

28 00:06:19.920 --> 00:06:42.040 Eli Shalom: That's the story we usually tell. It's not that we knew that it's going to be around block building, we knew, but it's going to be around one of the areas which suffer from over centralization. I'll elaborate on it in a second. But we weren't sure what exactly was going to be the product or what's going to be the and the length of the technology which we'll have to develop in order to

29 00:06:42.120 --> 00:06:50.409 Eli Shalom: achieve whatever it's going to be eventually it got to be something a little bit ambitious, challenging to develop.

30 00:06:50.560 --> 00:06:59.750 Eli Shalom: And and the reason for it is, and I'll have to explain a little bit what block builder is, and what block building is in blockchain.

31 00:06:59.750 --> 00:07:01.440 Gabor Szabo: Okay, please. Please. Go ahead.

32 00:07:01.440 --> 00:07:18.289 Eli Shalom: And so, blockchain as it sounds, it's a chain of blocks. So at every moment in the blockchain another block is added to the blockchain. And this is how the whole chain is being formed. So what does it mean to build a block or to add it to the chain?

33 00:07:18.290 --> 00:07:31.509 Eli Shalom: So in every moment in the blockchain. Some people want to send their transactions to the ethereum network. Sending a transaction means that someone wants to run a smart contract, which is

34 00:07:31.510 --> 00:07:44.579 Eli Shalom: a piece of code which can be verified before being executed, and can be verified about the actual execution it had, and it can be verified. So it means that if we have a smart contract.

35 00:07:45.040 --> 00:07:58.219 Eli Shalom: and which, for example, promises that we can swap assets between us, then nobody can change this code. And once we run this code, everyone can verify that, it ran exactly as the code shows.

36 00:07:58.360 --> 00:08:19.460 Eli Shalom: So that's something which sounds a little bit trivial or not very interesting, but when we look at a chain of transactions going into a single block, then they have a lot of side effects between them, because it's like a regular program. So when one transaction touches a variable

37 00:08:19.460 --> 00:08:39.220 Eli Shalom: in the ethereum network, then every transaction which comes after that will see exactly this side effect. So it means that ordering the transactions is a challenge. And this is where it's becoming interesting. So when we're looking at the problem of block building, it's just a problem of

38 00:08:39.620 --> 00:08:46.980 Eli Shalom: choosing a set of transactions and ordering them in the way which leads to the best or most valuable block.

39 00:08:47.620 --> 00:09:05.039 Eli Shalom: So this is something which is going to be with too many details, so we'll skip it. But the nice thing which is easy to explain is that building a block is an Np-hal problem. It's both equivalent to the permutation optimization problem. And it's also a knapsack problem.

40 00:09:05.040 --> 00:09:21.459 Eli Shalom: So we have to deal with Npr problem in order to be able to build a block. So this is the main premise of what we have to do. And the reason we're mentioning this and not anything else is. This is why we have to choose rust eventually.

41 00:09:21.570 --> 00:09:39.649 Eli Shalom: And so, if we have to summarize this in the most oversimplified way, and building a block is the challenge of ordering a set of transactions or set of actions, and trying to predict or getting to the most valuable order of those transactions.

42 00:09:39.750 --> 00:09:40.640 Eli Shalom: So

43 00:09:41.020 --> 00:10:02.810 Eli Shalom: if you have to look at it, you can look at it as a kind of a black box, and we give to the black box a set of transactions or a set of actions in a specific order, and we get a value. And if we change this order, we will get a different value. And what we're looking for is the most valuable ordering which we can create in order to build a block.

44 00:10:03.530 --> 00:10:08.489 Gabor Szabo: But who who builds the block? So I what I understood that there is the ethereum ethereum

45 00:10:09.370 --> 00:10:25.259 Gabor Szabo: network, or or I don't know. It's a virtual machine or the the service that runs on many computers. Okay, I read a little bit about it in the last couple of days. And isn't that doing the the ordering of these blocks.

46 00:10:25.620 --> 00:10:50.580 Eli Shalom: So the network itself is in charge of verifying that the blocks that the block builder created are, in fact valid, and can be satisfied as regular blocks which could be placed online and be checked by everyone else. So what we have is we have a few sets of very few block builders on ethereum. These are the entities which come before the transactions get to the blockchain itself.

47 00:10:50.770 --> 00:11:03.170 Eli Shalom: So we are off chain where, before the things get to the blockchain. And we get those all those inputs. We try to create a list of transactions in a way which is forming a potential block.

48 00:11:03.450 --> 00:11:27.369 Eli Shalom: And in every 12 seconds. In ethereum there is an auction, and every active block builder can propose the block to the network, and there is some kind of mechanism, how the block is being chosen, which practically says the most valuable block is being taken, and then the network goes to the validators and atchestrators who verify that the block is actually valid.

49 00:11:27.460 --> 00:11:36.649 Eli Shalom: but it respects everything on the smart contracts, and that all the results that it shows are, in fact valid for the execution the transactions had.

50 00:11:37.070 --> 00:11:57.490 Eli Shalom: So the block builder comes before the fury network, and before all the cool, decentralized entities it create. It creates a proposal for the network, and then the network chooses one of the proposals and verifies them with the nodes, validators, and other stakeholders.

51 00:11:58.100 --> 00:11:58.520 Gabor Szabo: Okay.

52 00:11:58.520 --> 00:12:17.119 Igal Tabachnik: So, if I may, I will also like to add so personally, I don't come from a background in blockchain. So I had to learn all this from scratch as well. Kind of a few months ago this was very new to me, and the way I understand it is very similar. It's very, very technical. But the idea is you have

53 00:12:17.420 --> 00:12:44.590 Igal Tabachnik: kind of like an Internet, a blockchain that's designed for executing code in the blockchain space called smart contracts. Smart contracts can be money transfers between different people, or there could be pieces of actual code like actual state that's being executed safely and cryptographically verifiable way. So the flow is that there are millions, or there are many, many

54 00:12:44.750 --> 00:12:59.239 Igal Tabachnik: hundreds of thousands of these transactions being created every second, and being placed in the network. What the blog builders do is they pick up those transactions from the ether pun intended from the network? We call them

55 00:12:59.240 --> 00:13:15.450 Igal Tabachnik: orders, and then the the goal of this block builder of what we do is like, Ellie said, is to try and create the best and the most valuable ordering of these transactions. So once this block containing all of these transactions.

56 00:13:15.760 --> 00:13:40.569 Igal Tabachnik: is created, we send it to those entities called the proposers. We propose the block, and then they can decide whether or not take this block. If they take this block, they can then publish it, and execute all of these transactions, and if not, every 12 seconds. This is the way the network works every 12 seconds. Everything repeats. So a new block is being created with new orders.

57 00:13:40.570 --> 00:13:57.229 Igal Tabachnik: etc, etc. So the idea is that we are the block builder, the block builder, which is what we do at Eureka is the entity that's responsible for actually turning those many of those transactions that are floating out there. Take them.

58 00:13:57.600 --> 00:14:02.410 Igal Tabachnik: order them in a way that they will be they. They will have the best chance of being picked up

59 00:14:02.810 --> 00:14:04.590 Igal Tabachnik: and executed.

60 00:14:05.210 --> 00:14:16.200 Igal Tabachnik: and and do it again and again and again, and so there are not too many entities out there that are called block builders. There are a couple of those. There are a couple of big names out there.

61 00:14:16.320 --> 00:14:32.749 Igal Tabachnik: and what we're trying to do is we're trying to. We're trying to to become yet another blockbuilder that's hopefully going to be powerful enough by doing some optimizations in a way that we create the blocks.

62 00:14:33.760 --> 00:14:36.079 Gabor Szabo: Okay, so basically, this log builder

63 00:14:36.680 --> 00:14:46.940 Gabor Szabo: will run or can run on on your your servers if I understand. So it's nothing really to do with the rest of the computers that are running the the blockchain.

64 00:14:47.180 --> 00:14:54.830 Gabor Szabo: They have some communication, but that it doesn't have to, and it can be either open source or proprietary right.

65 00:14:54.830 --> 00:15:17.350 Igal Tabachnik: Yeah. And that's kind of the point, the idea, the whole kind of the biggest reason why we chose rust. And I will just say it up front is, it's kind of, was a decision that was made for us. So there are some open source. Big, open source projects that propose give you building blocks to build your own block builder.

66 00:15:17.650 --> 00:15:36.219 Igal Tabachnik: So we essentially what we did, we forked that we, we took some existing open source infrastructure, and we forked it in a way that that we're adding our own modifications. But this, this entire infrastructure was written in rust.

67 00:15:36.970 --> 00:15:45.320 Igal Tabachnik: and so we kind of went with that. So the rust kind of has a strong presence in the blockchain space for historical reasons.

68 00:15:45.700 --> 00:15:52.610 Igal Tabachnik: But it's also very, very suitable, because in the end you're essentially, it's a server that gets deployed to the cloud

69 00:15:52.750 --> 00:15:59.920 Igal Tabachnik: like real actual machines that run in aws or whatnot. And essentially, it's a, it's a

70 00:16:00.220 --> 00:16:05.410 Igal Tabachnik: well, it's a network. It's a machine that listens to traffic on the, on the web.

71 00:16:05.720 --> 00:16:09.900 Igal Tabachnik: on the ethereum network. But it's essentially a service that runs out there.

72 00:16:10.060 --> 00:16:20.629 Gabor Szabo: So 2 2 questions. Come here. 1st of all, okay. So you forward. It is your code, or is it? Is it open source, or is it closed source, or how or what's going on with that.

73 00:16:21.440 --> 00:16:44.569 Eli Shalom: Is closed. Source we. If we see bugs or or improvements which are general to a general block builder we submit it back to the, to the original fork. But when we are developing new features, which are the new features, are, be a little bit beyond block building, and take advantage of what people can do with it. And so these things are not

74 00:16:44.690 --> 00:16:48.079 Eli Shalom: being opened open source.

75 00:16:48.470 --> 00:16:49.880 Eli Shalom: So we leave them closed doors.

76 00:16:49.880 --> 00:16:57.470 Igal Tabachnik: Yeah, okay, so the the license for it is, it's either Mit or Apache. So we we do submit.

77 00:16:57.470 --> 00:17:21.579 Igal Tabachnik: We do submit a couple of fixes upstream. So basically, that thing is being developed in the open, and we submit patches to it when we, when we can, those things that are going to be useful for for the general audience. But we kind of extend the product. Extend the platform in a way that's proprietary. And we right now it's not open source.

78 00:17:21.760 --> 00:17:37.200 Gabor Szabo: Okay? And then, so how? How do you earn money from this? Is it like, if your your block, if you're chaining, or whatever it's called. Your result is accepted. Then you earn some money. Do I understand correctly?

79 00:17:37.870 --> 00:17:54.070 Eli Shalom: Yeah, this is exactly how it works. And when a block builder wins an auction, and and this block builder gets a fee, it's varying between every block, but depending on how valuable you made it. Then this is how much fee the block builder can take.

80 00:17:54.070 --> 00:18:01.320 Gabor Szabo: Okay, so you have to be fast and clever. And yeah, basically, this, mostly these 2 things right?

81 00:18:01.885 --> 00:18:02.450 Igal Tabachnik: Exactly.

82 00:18:02.450 --> 00:18:03.030 Eli Shalom: That's.

83 00:18:03.030 --> 00:18:08.850 Igal Tabachnik: Primarily, primarily the reason why you would want to pick a language like rust to do this because you want to be both.

84 00:18:08.970 --> 00:18:13.350 Igal Tabachnik: Well, there are 3 things that you want to be. You want to be 1st and foremost correct.

85 00:18:13.470 --> 00:18:34.809 Igal Tabachnik: You need to. You need to ensure, because we're dealing with things that depend on. Well, they are order, sensitive, they're hard, but they also have to be verifiable in the end. There's a lot of verification steps and a lot of a lot of cryptographic hashes that go on, and those calculations need to be both very, very fast

86 00:18:34.970 --> 00:18:47.399 Igal Tabachnik: in terms of their execution. And also we have to be verifiably correct, which means that that when when the block that we create is going out to the network, we have to be able to

87 00:18:47.820 --> 00:19:11.519 Igal Tabachnik: ensure that it contains exactly what we said that it will contain. And this is where rusts, for example, type system makes certain guarantees that that ensures that the block will be created correctly and and verifiably. So. We have a bunch of tests around it. But also the type system ensures that the structs contain just the data that that is expected.

88 00:19:12.280 --> 00:19:30.020 Igal Tabachnik: And of course the performance because of it, because because rust is a very, very, it's a systems programming language in the end. So everything runs natively on the machine. There's no jit, there's no memory management. There's no garbage collection, so everything kind of runs very, very fast and

89 00:19:30.270 --> 00:19:35.999 Igal Tabachnik: in a way that that's expected of something that that sits in the network and deals with high traffic.

90 00:19:36.560 --> 00:19:39.359 Igal Tabachnik: The high deals with the high traffic essentially.

91 00:19:39.930 --> 00:19:42.810 Gabor Szabo: Was there any consideration or

92 00:19:43.050 --> 00:19:51.509 Gabor Szabo: so? Was there any consideration of using any other language, or it was so much given that that it it has. It was to be rushed

93 00:19:51.890 --> 00:19:54.480 Gabor Szabo: that you didn't even think about other language.

94 00:19:54.690 --> 00:20:05.739 Eli Shalom: So we did start with experimenting with other languages. So you, if surprisingly, we started with python, and we thought that we could just

95 00:20:05.980 --> 00:20:16.649 Eli Shalom: do all the heavy lifting on mathematical operations with numpy and stuff like that. But it was far from the reality and the reality. There needs to be a lot of

96 00:20:16.900 --> 00:20:29.679 Eli Shalom: real execution of code on Evm and Python will never get to the right performance. So this was an approach we had to ditch quite fast and the other competitor is go.

97 00:20:29.700 --> 00:20:58.249 Eli Shalom: So a lot of projects are based in Go, and also one of the largest block builders in ethereum, also implemented in go, and the reason we had to choose between these 2 is whether there is a main entity called the node, which holds all the information in locally for the ethereum network. So when building a block, there needs to be a lot of access to the storage of the network, and it has to be

98 00:20:58.250 --> 00:21:22.210 Eli Shalom: placed locally. And one of the things we realized that it's very efficient to write in the same language. And like the node we're walking with because they can share some code. They can share processes inside the same machine. And then they can share memory. So basically, the reason to choose rust was because the main node we're using is implemented in rust.

99 00:21:22.610 --> 00:21:29.960 Eli Shalom: So this leads a lot of the choices of companies to work in blockchain to work with rust because

100 00:21:29.970 --> 00:21:54.799 Eli Shalom: there's a main entity to work with. It can be communicated as a black box like in Http. Or it can. It has extensions where people can run things inside the same process of the node itself, and if we run our builder as close as we can to the node, and if we write it in last, and we can share the same memory, and then we can get the best in the best performance.

101 00:21:54.800 --> 00:21:58.282 Igal Tabachnik: Yeah. And also there are additional benefits. For example,

102 00:21:58.820 --> 00:22:20.249 Igal Tabachnik: the the node itself. It's called rus, RETH. So it's a rust implementation of the ethereum network. It's also open source, and it introduces a lot of libraries that we use internally, that provide you with primitives for the system, everything from holding, describing sums of money.

103 00:22:21.380 --> 00:22:24.480 Igal Tabachnik: and yes, exactly. RATH. Reth.

104 00:22:24.480 --> 00:22:29.280 Gabor Szabo: I just wrote the Free People listening to us. I just wrote it in the chat because I wasn't sure.

105 00:22:29.340 --> 00:22:29.990 Igal Tabachnik: Yeah, yeah.

106 00:22:30.247 --> 00:22:33.339 Gabor Szabo: And the. And so I'm going to put it on in the.

107 00:22:33.340 --> 00:22:40.419 Igal Tabachnik: In fact, I made a bunch of links of things that we're going to mention, and maybe we can put them in the end as like a show notes.

108 00:22:40.630 --> 00:22:42.520 Gabor Szabo: That would be a very good idea. Thank you.

109 00:22:42.960 --> 00:23:08.489 Igal Tabachnik: So, yeah, the idea is that a lot of libraries that can be reused like with primitives, with abstractions, with, for example, if the ethereum network implements, a lot of protocols which are all published. They're all kind of described in white papers. It's all fascinating. Everything is kind of documented, and there are a bunch of different implementations, and the most popular ones are in go and rust.

110 00:23:08.530 --> 00:23:23.440 Igal Tabachnik: And so the the rust implementations are really, they're very robust, and they're very, I would say, idiomatic to the rust language. So everything works as you would expect a real rust code to work. So, for example.

111 00:23:23.710 --> 00:23:46.129 Igal Tabachnik: you have a bounce checking, and you have smart macros. So, for example, you have even things like addresses. If you want to send, like everything in ethereum is like an address from and to. So you have to know who you're sending from and who you're sending to, whether it's money or anything else. And this is just a big hacks number.

112 00:23:46.290 --> 00:24:03.049 Igal Tabachnik: And so, in order for you not to spend any time parsing strings or just dealing with general validation of whether or not you were given a correct address. You just use a macro, for example, there's a macro in these building blocks called address bang.

113 00:24:03.050 --> 00:24:20.959 Igal Tabachnik: which in compile time validates that you that you are using correct address. So it alleviates a lot of headaches and a lot of kind of these small mistakes that you can get with languages that are not as robust. Probably for dealing with this like, you can probably implement

114 00:24:21.020 --> 00:24:25.869 Igal Tabachnik: any of these things in any other language, even like, obviously people do it in go.

115 00:24:25.920 --> 00:24:41.199 Igal Tabachnik: But the added benefit of rust from my perspective, as somebody who uses daily is that all of these little patterns that the language encourages you to do like going through safe methods and and implementing safe conversions

116 00:24:41.230 --> 00:25:00.830 Igal Tabachnik: ensures that you're less likely to make a mistake, especially when you're building payloads and parsing payloads at Runtime. You're more or less guaranteed that your execution will be flawless as long as you handle everything during compilation during design time of your program.

117 00:25:01.040 --> 00:25:12.020 Igal Tabachnik: And this is again. This is one of the primary reasons why, in the end we chose rust is that there's this added guarantee of safety that the language is built upon.

118 00:25:12.430 --> 00:25:16.090 Igal Tabachnik: It provides you with a lot of a lot of

119 00:25:16.220 --> 00:25:22.039 Igal Tabachnik: functionality, so to speak, that ensures that many, many of these things

120 00:25:22.470 --> 00:25:36.849 Igal Tabachnik: the compiler will handle for you, and if you're making a mistake, the compiler will aid you and tell you what exactly you're doing wrong, and so you will have much fewer runtime surprises, which is, in my opinion, is the the best possible thing that rost can do.

121 00:25:38.020 --> 00:25:52.429 Gabor Szabo: Right back to a little bit for my understanding. You mentioned Node. That there are there are these nodes, isn't network is is just these notes. So when I say when you say the at the room at the room.

122 00:25:53.190 --> 00:25:54.500 Igal Tabachnik: That. Yeah.

123 00:25:54.620 --> 00:25:57.690 Gabor Szabo: When you say at the room, it's basically just the notes right.

124 00:25:57.690 --> 00:25:58.280 Eli Shalom: Yes.

125 00:25:58.550 --> 00:26:08.170 Gabor Szabo: Okay, so and so the the and it's an open as much as I understand. That's an open source project, basically right? Written in rust.

126 00:26:09.080 --> 00:26:11.030 Gabor Szabo: So all these notes are written in rust.

127 00:26:11.420 --> 00:26:13.819 Eli Shalom: So there are many implementations of the nodes.

128 00:26:13.820 --> 00:26:14.630 Gabor Szabo: Okay.

129 00:26:14.630 --> 00:26:17.190 Eli Shalom: The most popular ones are in. Go and rust.

130 00:26:18.070 --> 00:26:25.150 Gabor Szabo: Okay? So the notes. So also there are different implementation of nodes. Not just the the block builders.

131 00:26:25.150 --> 00:26:30.219 Eli Shalom: Yeah, there, there could be infinite implementations for the for the for the nodes.

132 00:26:30.220 --> 00:26:35.350 Gabor Szabo: Okay. And then I guess there is some Api or some definition that that they must

133 00:26:35.640 --> 00:26:37.890 Gabor Szabo: and work this way.

134 00:26:38.280 --> 00:27:01.370 Igal Tabachnik: There's a spec basically on ethereum.org. You have the entire spec. All the white papers of many smart people wrote many years ago, and all of these things are just implementations, and yes, they have to agree on a common protocol and a common language. Essentially. In the end your payloads are encoded in. There's a special type of encoding.

135 00:27:01.940 --> 00:27:06.569 Igal Tabachnik: There's a special type of encoding of how the actual raw data looks

136 00:27:06.790 --> 00:27:16.910 Igal Tabachnik: on the on the wire, but every every implementation, whether it's go or or rust, or anything else. Really, I've seen. I've seen people do it in Javascript as well, of course.

137 00:27:17.200 --> 00:27:19.749 Igal Tabachnik: because everything can be done in Javascript.

138 00:27:20.320 --> 00:27:24.680 Igal Tabachnik: They all are able to to handle it and and talk to each other.

139 00:27:25.150 --> 00:27:50.189 Gabor Szabo: So how do? How do they manage upgrades? I mean, if 1 1 of these notes so if they want to introduce a new service, or I don't know whatever new something into the network. Then someone implements it in one type of the notes, and and then the others don't know about it so, or they are not implemented yet. So not not only talking about, not even

140 00:27:50.470 --> 00:27:52.530 Gabor Szabo: not talking about

141 00:27:53.060 --> 00:28:03.820 Gabor Szabo: rolling out to the same code base, to maybe hundreds or thousands of nodes. Which itself is a is a is a problem. But if they're each node might be in different

142 00:28:04.410 --> 00:28:06.589 Gabor Szabo: might be a different code base.

143 00:28:07.420 --> 00:28:18.589 Gabor Szabo: Then how can they make make progress? Or what happens if what I mean? Okay? So you add the new feature, then it can't work yet, because the others

144 00:28:19.010 --> 00:28:20.850 Gabor Szabo: don't understand it yet.

145 00:28:21.810 --> 00:28:44.400 Eli Shalom: Yeah. So on the network, nobody can add a new feature on their own, and the idea for which there are many nodes is to get to a majority, and the right thing is always what the majority says. So if you have just one node which decides to deviate from the others, and this node will be disregarded, because it will always be the minority, and nobody will

146 00:28:44.550 --> 00:28:52.350 Eli Shalom: take it seriously. Usually this node will get punished, and and the reputation will be harmed or slashed. I'm not exactly sure how they.

147 00:28:52.460 --> 00:29:02.120 Eli Shalom: being incentivized not to do it, but a node can't, can decide on it on its own, to change the behavior and.

148 00:29:02.570 --> 00:29:03.020 Gabor Szabo: Behind.

149 00:29:03.910 --> 00:29:04.670 Eli Shalom: Yeah, but.

150 00:29:04.670 --> 00:29:11.999 Gabor Szabo: Right. If if all of them are moving ahead to something, then then I also have to move, because otherwise I'll be different right?

151 00:29:12.000 --> 00:29:36.389 Eli Shalom: Definitely so the idea of the majority holds all the time. So once a big change needs to come to ethereum. Usually it comes from the ethereum foundation, and they promote it through something called eap. It's an improvement proposal for ethereum. It takes very long time to get to an agreement, and once it's done and the spec of the nodes

152 00:29:36.390 --> 00:29:42.940 Eli Shalom: changes, and then the community decides on a date in which all the nodes have to change to the new version.

153 00:29:43.950 --> 00:29:44.620 Gabor Szabo: Hmm.

154 00:29:44.620 --> 00:30:12.940 Igal Tabachnik: Yeah. So the idea? Yes, this is the protocol governed by the ethereum foundation and all the major upgrades to this to the way the protocol works has to be documented, agreed upon, discussed potentially for many years, until they finally pick up a code name which is usually a weird name of some sort, or maybe like a city. There was, I think there was something called London. Maybe I don't remember exactly. And yeah, they decide to switch.

155 00:30:13.040 --> 00:30:31.269 Igal Tabachnik: And so yeah, so those things don't just nobody can really add a feature to the ethereum network because it has to be. It's like, it's like, I don't know. It's like would be adding a new feature to the Internet that would not make real like to Tcp, IP. It would have to go probably through.

156 00:30:31.610 --> 00:30:49.609 Gabor Szabo: Yeah, yeah, yeah, those are the standards. Yeah. So you have to go with the standard. I mean, you could add the new service to the Internet, and you start doing with between 2 computers. But if if you want to change how the Tcp IP protocol works well, that good.

157 00:30:49.610 --> 00:30:50.100 Igal Tabachnik: Live.

158 00:30:50.490 --> 00:30:54.700 Gabor Szabo: Or how even what Http is, or whatever yeah, right?

159 00:30:54.700 --> 00:30:55.710 Igal Tabachnik: Yeah, yeah.

160 00:30:57.385 --> 00:30:58.580 Gabor Szabo: So

161 00:30:58.730 --> 00:31:12.979 Gabor Szabo: what else? I wanted to ask something else about this? Oh, yeah. Yeah. How many notes are there? This is something that I was. How many notes are there in the network like more or less? It's thousands or millions or.

162 00:31:13.360 --> 00:31:31.160 Eli Shalom: No, it's it's a lot. There are 1 million registered nodes which perform validation. It's something which forces them to be up and to be like a very active node. So there are just 1 million nodes of validators, and there are many 1 million of other nodes

163 00:31:31.300 --> 00:31:37.309 Eli Shalom: which are just out just collecting data, storing them locally like we do. So it's a few millions.

164 00:31:37.700 --> 00:32:04.510 Gabor Szabo: Okay. So the point is, or when I started to learn a little bit about about blockchain. And then I understood, okay, there's a majority decides. That's the point that more or less where I reached in my understanding. And then I was wondering, okay, fine majority decides. But if there is a wealthy person or a country that wants to overtake this whole thing. Then they can build.

165 00:32:04.730 --> 00:32:12.970 Gabor Szabo: set up a lot of these machines, and I was wondering how, how big, how big that needs to be in order to become a majority.

166 00:32:13.370 --> 00:32:18.000 Gabor Szabo: So I guess if it's a couple of millions, then then it's a lot.

167 00:32:18.350 --> 00:32:23.539 Gabor Szabo: And I guess these are not simple machines, right? So they they

168 00:32:23.640 --> 00:32:26.500 Gabor Szabo: very. They need to be very powerful machines, right?

169 00:32:26.870 --> 00:32:27.750 Gabor Szabo: The notes.

170 00:32:28.107 --> 00:32:57.040 Eli Shalom: They're not like the smallest or cheapest machines, but it's not like a like Aws machines of 5,000 bucks a month. Usually it's like medium sized machines with a lot of storage like holding the node takes a few terabytes of data, which is usually where most of the cost comes. And this is what makes it also very, very challenging to spin up a node. Take about 48 to 72 h until it becomes synced until it

171 00:32:57.602 --> 00:33:01.730 Eli Shalom: takes all the information from other nodes and verifies it.

172 00:33:02.530 --> 00:33:03.130 Gabor Szabo: Okay.

173 00:33:03.170 --> 00:33:15.490 Igal Tabachnik: Because because also, yeah, you have to remember that the the idea behind the blockchain in general is because it is immutable. Everything that happened is historical and cannot cannot ever change, because it was

174 00:33:15.490 --> 00:33:24.099 Igal Tabachnik: it was reached like a consensus was reached that this node, this this block, was placed on the network, and it will be there forever.

175 00:33:24.100 --> 00:33:46.479 Igal Tabachnik: In order for you to modify, you have to create a new one. And so basically, the latest version will be the current, but historically you can always look ahead, and every time you need to spin up a new server or a new node, or whatever you have to fetch all of the historical data from you have to pre-populate it. And this is what that means that it takes a lot of time and a lot of storage.

176 00:33:46.670 --> 00:33:54.349 Gabor Szabo: So the the existing chain that there is all the the chain of the blocks that already have. That's a couple of terabyte of data already.

177 00:33:54.770 --> 00:33:55.400 Eli Shalom: Yep.

178 00:33:56.420 --> 00:34:03.099 Gabor Szabo: And how long that has accumulated like 10 years. Right, I think, at the room, at the wrong.

179 00:34:03.509 --> 00:34:05.660 Eli Shalom: I would say probably. Yes, but I'm not sure.

180 00:34:06.120 --> 00:34:25.689 Gabor Szabo: So I was wondering, okay, it's just going to grow more and more. And then, okay, a lot of disk space is going to be used. My understanding is that basically, this is very similar to what? How the data of git looks like, except, of course, without branching.

181 00:34:26.370 --> 00:34:33.260 Gabor Szabo: Now, the ability to go back in storage.

182 00:34:33.860 --> 00:34:34.730 Gabor Szabo: Sorry.

183 00:34:34.730 --> 00:34:38.080 Eli Shalom: We don't have the way to go back like in in git. So versioning.

184 00:34:38.080 --> 00:34:46.250 Gabor Szabo: So indeed you could you could you? Could you could remove all the recent commits and and whatever here we I mean

185 00:34:47.020 --> 00:34:52.670 Gabor Szabo: the same here. You could do this if you could convince all of enough notes right.

186 00:34:52.670 --> 00:34:52.975 Eli Shalom: Yep.

187 00:34:53.750 --> 00:34:57.129 Gabor Szabo: Basically. And okay.

188 00:34:57.570 --> 00:35:07.400 Gabor Szabo: interesting. So let's get back to rust a little bit. And and you, so how did you get started with rust?

189 00:35:09.780 --> 00:35:11.510 Igal Tabachnik: Do you mean me, or Ellie?

190 00:35:11.740 --> 00:35:13.870 Gabor Szabo: One after another.

191 00:35:14.580 --> 00:35:22.220 Igal Tabachnik: All right. I think I'll start then. So, like I mentioned earlier, my my journey to Rust was a bit different. So over the past.

192 00:35:22.360 --> 00:35:52.110 Igal Tabachnik: I want to say. Almost 10 years I've been dealing with well, dealing. Dealing is a choice word. I've been working primarily with Scala and through Scala, which is a language on the Jvm kind of it's this hybrid, object-oriented, functional language I discovered functional programming and functional programming became something that I really fell in love with, and so I later learned Haskell and other kind of languages that belong to that family.

193 00:35:52.630 --> 00:36:20.429 Igal Tabachnik: and through functional programming I discovered many of the benefits that kind of were pioneered in functional languages, and then picked up by every other programming language in the world. So, for example, things like virtual threads or green threads, as they're known in other languages. They were 1st introduced in Haskell, and then they were pioneered in Scala, and now Java has them, and of course, rust have them in

194 00:36:20.430 --> 00:36:24.529 Igal Tabachnik: basically Tokyo is the implementation of virtual threads

195 00:36:24.680 --> 00:36:44.340 Igal Tabachnik: and the whole notion of immutability and working with immutable data and transformations, like in C sharp, they would be called link. In other languages they would be called working with collections and lambdas and iterators. There was kind of all of these features were kind of

196 00:36:44.540 --> 00:36:57.339 Igal Tabachnik: I wouldn't say pioneered, but they were heavily, heavily used in functional languages primarily, because you don't have as many variables and and and mutation going on. So you have chains and transformations of data.

197 00:36:57.820 --> 00:36:58.973 Igal Tabachnik: And so

198 00:37:00.680 --> 00:37:25.849 Igal Tabachnik: unfortunately, I want to say, like, I'll be frank, that unfortunately, Scala is notoriously hard to teach because of that, because you can use it as a kind of a Java with this different syntax. But this does not really give you that much of a benefit, especially today when you have languages like Kotlin, or other things that work on the Jvm. That don't necessarily require the full power of a language like Scala.

199 00:37:26.060 --> 00:37:34.979 Igal Tabachnik: and so many, many companies that were previously using Scala. They're kind of not really starting new projects on that. So they're kind of moving away.

200 00:37:35.020 --> 00:37:59.460 Igal Tabachnik: And so I was actually looking to do some more Scala, and it was becoming challenging. And so my options were either to go kind of into the mainstream and do maybe a little bit of Kotlin, or even typescript. And there are not a whole lot of choices for doing backend engineering, but most of it revolves today around

201 00:37:59.460 --> 00:38:05.950 Igal Tabachnik: Java and Kotlin and typescript on the back end. There's some python, probably.

202 00:38:06.180 --> 00:38:35.609 Igal Tabachnik: or I really wanted to look at this language called rust, because what I knew of rust is that it was yes, it was kind of a type, safe, very performant language that was created by Mozilla for a certain purpose. But what I knew of rust is that it was designed in a way that it borrowed a lot of features from functional languages. In particular. If you look at the way that rust is designed, it borrows a lot of ideas from, for example, from Haskell.

203 00:38:35.630 --> 00:38:40.380 Igal Tabachnik: which is which is known to be like a pure functional language.

204 00:38:40.460 --> 00:39:10.010 Igal Tabachnik: But in rust, for example, the derivation mechanism. So the way that you attach essentially behavior to structs with the derived keyword. This is an exact copy of a feature from Haskell. It's called type classes, but this is a feature that was that exists in Haskell and was adapted to many other programming languages. And, in my opinion, this is one of the most amazing features that rust has, because it allows you to precisely define behavior to a set of

205 00:39:10.010 --> 00:39:17.199 Igal Tabachnik: a set of structure, a set of traits, essentially, traits become behaviors, and you can apply them

206 00:39:17.640 --> 00:39:30.200 Igal Tabachnik: externally to the data. So, whereas you have in many object oriented languages, you are encouraged to kind of create behavior and data together in the same class.

207 00:39:30.580 --> 00:39:51.219 Igal Tabachnik: in function, languages in rust. Specifically, you are encouraged to keep them separate. So you have structs that hold just the data, and you have traits and implementations of those traits as behaviors which can be attached and reattached and and defined, and most importantly verified at compile time.

208 00:39:51.790 --> 00:40:08.670 Igal Tabachnik: So 1 1 such example is that something I've encountered yesterday. So I was refactoring a piece of code, and I needed to store 2 new fields, or at least one new field of type float. I needed the floating point number to be stored in a configuration somewhere.

209 00:40:09.040 --> 00:40:16.560 Igal Tabachnik: I got a compilation error that said I cannot use, derive Eq. Derive equality

210 00:40:16.650 --> 00:40:40.509 Igal Tabachnik: for a type F. 64. And this makes complete sense. You cannot. Computers do not like comparing floating point numbers. This is an impossible problem. Now, there are many, many programming languages that are happily going to let you compare 2 floating point numbers, and the end result will probably not be what you need. What you expect, so you will have some issue with Runtime.

211 00:40:40.620 --> 00:40:52.500 Igal Tabachnik: but Rust was smart enough to figure out that you cannot derive equality for the entire config class, because the float type F, 64 does not implement the IC trait.

212 00:40:52.710 --> 00:41:02.510 Igal Tabachnik: And this is why you get a compilation error, and it makes perfect sense. And the point is that in rust I found that many, many of these things are like this.

213 00:41:02.840 --> 00:41:03.675 Igal Tabachnik: So

214 00:41:04.520 --> 00:41:19.460 Igal Tabachnik: I'm just going to say that that people who are coming to Russ. They hear stories about this compiler and the borrow checker being in your way constantly, and you and you have to kind of fight the borrow checker, so to speak, to, to get

215 00:41:19.460 --> 00:41:35.550 Igal Tabachnik: to get to the point. But I think that's the wrong way of looking at it. I think the compiler is there obviously to prevent invalid behavior invalid programs undefined behavior. So this is one of the core principles of rust is to be safe. The safety is achieved by

216 00:41:35.960 --> 00:41:39.689 Igal Tabachnik: it's preventing you from doing things that will obviously not work.

217 00:41:40.240 --> 00:41:58.120 Igal Tabachnik: and many, many smart people created it. And I've seen many talks by the creators of Rust, by Grayden Hoare, who talks about the kind of the history and why they did things the way that they did. But the main idea is that rust borrows many of those features from

218 00:41:58.310 --> 00:42:08.630 Igal Tabachnik: languages that have strong and static type systems that kind of are in your way. But in order for you to to prevent you from doing kind of the wrong thing.

219 00:42:09.390 --> 00:42:35.839 Igal Tabachnik: And finally, I'm going to say that one such mention about the borrow checkers. This is something I heard from a friend who does not do any rust. He's a scholar programmer. But he asked me, don't you get to fight the borrow checker a lot, and I would say that this notion of fighting the borrow checker is kind of a meme. It's kind of a myth in the rust world, because it is being sold as this kind of

220 00:42:36.140 --> 00:42:49.220 Igal Tabachnik: this kind of novelty feature that the rust compiler has. It has this notion of a borrow checker. But the idea there is that because it has manual memory management, you don't want to be doing things that are wrong.

221 00:42:49.440 --> 00:43:10.099 Igal Tabachnik: So if you want to pass a mutable variable to another function. You have to explicitly allow it to to be to be passed as mutable because somebody can modify it under your feet. And the scholar, the rust compiler is smart enough to detect such cases and tell you, no, you're doing something very, very wrong.

222 00:43:10.280 --> 00:43:12.960 Igal Tabachnik: and so it's not there to to kind of

223 00:43:13.640 --> 00:43:22.490 Igal Tabachnik: prevent you from doing stuff. It's there to guide you of saying, Okay, I know what you're trying to do, but there are ways of doing it, and you better, so better stick to the ways.

224 00:43:22.640 --> 00:43:33.460 Igal Tabachnik: And finally, the last kind of it's more of a philosophical thing that I'm going to say is that there's this notion again, coming from functional languages. It's it's a thing that's called.

225 00:43:33.900 --> 00:43:50.620 Igal Tabachnik: It's based on a very good talk that I watched many years ago. It's this notion of constraints, liberate and liberties constrain. So the idea is that if you don't have any constraints and you can do just whatever you want like in in

226 00:43:50.670 --> 00:44:13.329 Igal Tabachnik: other programming languages. Javascript. So if you don't have any constraints whatsoever, so you can do just whatever you want, which means you can do it in any way that you want in any style that you want, in any order that you want, probably. And then what you have is down the line. You will have problems. You will have runtime issues. You will have refactoring challenges, and you will have many, many things that we know and love about

227 00:44:13.420 --> 00:44:14.949 Igal Tabachnik: to languages like Javascript.

228 00:44:15.560 --> 00:44:31.210 Igal Tabachnik: Now, if you have a system that's constrained, it does not let you do what you want, but it rather expects you to follow its exact kind of guidelines and its exact path that it guides you through, that there are very, very few ways in which you can implement something. So

229 00:44:31.800 --> 00:44:46.129 Igal Tabachnik: this notion of of constraints. Liberate is is that when you are constrained kind of it sounds paradoxical, but when you are constrained by by the the system that you are building it by the type system, by the the borrow checker or whatnot.

230 00:44:46.350 --> 00:44:52.860 Igal Tabachnik: You are then free to kind of implement it in the only way that will work. And so you don't have to worry about that.

231 00:44:53.200 --> 00:45:05.420 Igal Tabachnik: And that's for me. That's just one of the the most tremendous benefits of using a language like rust, and also I'll have to give credit where credit is due. Also languages like Scala and languages like

232 00:45:05.730 --> 00:45:21.399 Igal Tabachnik: Haskell, of course, and there are some some other languages that on the Microsoft side there's F sharp. Many, many functional languages embrace this principle, and, of course, type system really helps. So if you don't have types to guide you. You have to write a lot of tests.

233 00:45:21.520 --> 00:45:48.959 Igal Tabachnik: and we can debate whether or not writing tests is a fun activity. Now that ais can do it for us. But I would say that types from my perspective come before tests. They can prevent many, many of invalid behaviors even making writing these tests unnecessary for things that cannot possibly compile. Okay, and with that I'm going to stop talking for now. And, please, if you have any, follow ups, I would.

234 00:45:48.960 --> 00:45:58.789 Gabor Szabo: Yeah. So before letting Ellie also say, I wanted to ask you, how did you solve that problem with the floating point, comparing floating numbers?

235 00:45:58.790 --> 00:45:59.520 Gabor Szabo: Oh.

236 00:45:59.670 --> 00:46:21.149 Igal Tabachnik: Well, well, the point is, I needed to store a percentage a multiplier for a percentage. I ended up storing it as just as just a decimal number of, I just switched it to a U to U, 64, I used a different multiplier, essentially. But yeah, it's just one of these things.

237 00:46:22.280 --> 00:46:23.040 Gabor Szabo: Okay.

238 00:46:23.360 --> 00:46:24.090 Gabor Szabo: Good.

239 00:46:25.170 --> 00:46:32.530 Igal Tabachnik: So I changed. Yeah, I changed the data type. Essentially, I didn't try to hack around the problem. I just, I solved it using a different data type.

240 00:46:35.920 --> 00:46:56.269 Eli Shalom: So I guess my version is going to be a little bit more dull, but it's going to go through the same main theme of the language guiding us towards the right thing. So when we started working with Russ, it was the 1st time we coded in the language, and both my partner and I didn't code.

241 00:46:56.340 --> 00:46:57.240 Eli Shalom: and

242 00:46:57.290 --> 00:47:18.670 Eli Shalom: in that intensity for a very long time, especially me as a data science, I didn't do such things for a very, very long time. And when we started working on the software it was something which did a lot of things in parallel. We got a lot of data from many sources in parallel. We had to do a lot of computations in parallel and store them back to the same sources in parallel.

243 00:47:18.670 --> 00:47:28.339 Eli Shalom: And one of the things we started feeling at the beginning is that we're fighting the Borough checker all the time, and that it's just interfering with our work.

244 00:47:28.450 --> 00:47:46.360 Eli Shalom: Eventually, like probably something which happens to most rust developers. We started to figure out what's the right thing to do when we need to clone an object when we have to show it with an arc, and when we have to use a lock to show the object between different components

245 00:47:46.360 --> 00:47:58.600 Eli Shalom: and one of the things which really impressed us after the 1st month was that it was a very large system in regards to the amount of parallelization it did, and it had no locks at all

246 00:47:58.730 --> 00:48:19.469 Eli Shalom: in any software, in any other language I use. I was going to write and use a mutex in many places to to synchronize, and here, because the language just encourages the developers to think about who owns each object, it just led us to write it in a way which didn't require any lock.

247 00:48:19.470 --> 00:48:29.090 Eli Shalom: and the performance was great, not just because it was rust, also because it had no locks, and we didn't have to wait in any place which we wouldn't have happened

248 00:48:29.520 --> 00:48:31.859 Eli Shalom: in probably any other language we used.

249 00:48:33.460 --> 00:48:40.839 Gabor Szabo: Very interesting, very interesting. Okay, so let's go further with Rust. You said that

250 00:48:41.020 --> 00:48:48.880 Gabor Szabo: part of the reason you selected rust is because, or part of the advantages that you have from rust is that you have a lot of libraries

251 00:48:49.010 --> 00:48:56.080 Gabor Szabo: crates that you can already use because they are part of the the node. Basically right?

252 00:48:56.230 --> 00:48:58.810 Igal Tabachnik: So those are given.

253 00:48:59.070 --> 00:49:13.529 Gabor Szabo: That are part of the node, and you're going to use it. And and whatever I mean, even even there might be, the question is, is valid, but I'm quite sure that you have also all kind of other crates that you are using. I mean, every rust project uses hundreds of crates.

254 00:49:13.530 --> 00:49:13.930 Igal Tabachnik: Right.

255 00:49:13.970 --> 00:49:21.484 Gabor Szabo: How do you? How do you? How do you? How do you select the create? How do you make sure?

256 00:49:22.500 --> 00:49:23.889 Gabor Szabo: it's quality?

257 00:49:24.050 --> 00:49:30.290 Gabor Szabo: Yeah. Well, that's a very good question. I will say that at least until now.

258 00:49:30.560 --> 00:49:57.839 Igal Tabachnik: Because because the the platform itself that we that we are basing upon it was already kind of it, more or less, batteries included. It has everything that we would need to to kind of build upon upon it. It's an SDK, essentially so. I I don't remember if we needed to add an external crate other than possibly, I think it was like

259 00:49:58.190 --> 00:50:24.179 Igal Tabachnik: some data types for that have to do with with ethereum protocols like we, we needed to to bring in one more protocol that we needed to support, and I think there was a crate for that. But but it's just a matter of you know, Googling, for rust, and whatever it is you're looking for and looking at top. 2 results. Now, I would say that most of the the crates that are used. They are used mostly by reputation.

260 00:50:24.440 --> 00:50:42.159 Igal Tabachnik: so I wouldn't say necessarily number of stars. But it's more like a word of mouth thing that if you. For example, if you're building a cli tool and you need a command line argument, parser. So you would probably use clap. Why? Because everybody uses clap. And this is like in every book and every tutorial.

261 00:50:42.540 --> 00:50:57.739 Igal Tabachnik: And so, if you need, obviously, if you need a synchrony, you would use Tokyo, and I know that there are other implementations, but they are maybe not as not as as powerful, or maybe not as as popular.

262 00:50:57.970 --> 00:51:16.860 Igal Tabachnik: Maybe they have their uses, but Tokyo seems to be kind of the I wouldn't say Standard Library, but it's kind of the de facto thing that everybody else uses, and of course you need to think about interoperability. So to answer the question, I would say, if we needed to, we would probably choose it by reputation. So

263 00:51:17.120 --> 00:51:41.230 Igal Tabachnik: how popular it is, whether or not it's registered in the official website. Can I even pull it from like? Can I even add it to my toml file and just rebuild and everything will compile. Or do I need to add some 3rd party, github Urls to my, to my configs, to pull it from source stuff like that.

264 00:51:41.230 --> 00:51:44.499 Gabor Szabo: You encounter encounter Chris like that, I mean I.

265 00:51:44.500 --> 00:51:49.170 Igal Tabachnik: But I suppose that there are private implementations somewhere that do not are not published.

266 00:51:49.340 --> 00:51:53.340 Igal Tabachnik: I, personally haven't encountered that yet, but I'm.

267 00:51:53.340 --> 00:52:04.929 Gabor Szabo: Item number that I encountered is that that you can't just Pip installs the latest, or from single app only. But you have to go to that there I encountered. But maybe that's fortunately, because

268 00:52:05.550 --> 00:52:09.919 Gabor Szabo: I don't know, because Python is older and more and.

269 00:52:09.920 --> 00:52:18.490 Igal Tabachnik: And rusted becomes very easy, because version pinning is very important, like you have the log files, and and I think I think

270 00:52:18.760 --> 00:52:36.550 Igal Tabachnik: from many like package management software that I've used over the years. I think Ross did it really great because it it kind of works. And and it tells you what the latest versions are. It figures out mismatched versions between like, if you have dependencies between crates.

271 00:52:37.540 --> 00:52:51.030 Igal Tabachnik: the rust will tell you, and enabling features independently. So if you, for example, you needed to enable Tokyo for a certain crust, if it supports it, then they have certain crate.

272 00:52:51.820 --> 00:52:52.710 Igal Tabachnik: I think.

273 00:52:53.560 --> 00:53:17.999 Igal Tabachnik: like I think, that they did a really good job, like rust, in my opinion, is one of the most well engineered languages that provides you with developer productivity. There are very few like the only one I can possibly think of that that does at least as good job is a language called elm, which is a web language. That's also kind of functional, and it also has its roots in

274 00:53:18.000 --> 00:53:28.659 Igal Tabachnik: Haskell, like syntax, but its package management and its errors are just amazing. It will tell you exactly what happened and how to solve it.

275 00:53:28.710 --> 00:53:32.250 Igal Tabachnik: and, in fact, kind of jumping is an aside.

276 00:53:32.470 --> 00:53:47.559 Igal Tabachnik: Rust's errors are notoriously yes, they can be overwhelming sometimes, but they're notoriously so detailed is that you have AI tools today that just figure all the errors out and explain to you what went wrong

277 00:53:47.560 --> 00:54:09.469 Igal Tabachnik: and just fix it for you. This is something I encounter daily, even if I don't want it. Sometimes I do encounter an issue with borrowing or stuff like that, or forgetting to clone something. So sometimes I want to get my task done. So I don't really want to think about it. So I just press the little icon

278 00:54:09.470 --> 00:54:27.019 Igal Tabachnik: in my intelligent, it tells me fix with AI, and it just does. Why? Because it has a lot of context for what went wrong, and the Llms are now smart enough to kind of feed this context. Read this context and just figure it out and give me all the information. So I don't have to Google. I don't have to read docs.

279 00:54:27.160 --> 00:54:31.639 Igal Tabachnik: It's it's it's it's really an amazing flow that

280 00:54:32.450 --> 00:54:39.589 Igal Tabachnik: it's just incredible to me. I've been doing software for many years now, and and I don't remember anything remotely

281 00:54:39.920 --> 00:54:45.259 Igal Tabachnik: advancing in this in this incredible rate, like like AI and AI, assisted tools.

282 00:54:46.620 --> 00:54:49.220 Gabor Szabo: About the AI. Let's.

283 00:54:50.300 --> 00:54:51.550 Igal Tabachnik: It was topic to topic.

284 00:54:51.550 --> 00:54:52.030 Igal Tabachnik: Yep.

285 00:54:52.950 --> 00:54:55.389 Gabor Szabo: No, no, I'm I'm glad we're talking about AI. That's it.

286 00:54:55.470 --> 00:55:08.559 Gabor Szabo: Okay. So I wanted to ask about AI, if you're already talking about this, how much do you use? AI, which AI tools do you have you experienced? With which one do you feel the best

287 00:55:09.740 --> 00:55:13.190 Gabor Szabo: for? Especially for us? Development? Of course.

288 00:55:13.620 --> 00:55:15.750 Igal Tabachnik: Sure, Eddie, you want to go first.st

289 00:55:15.750 --> 00:55:17.450 Eli Shalom: No, no, that's yours.

290 00:55:17.740 --> 00:55:41.310 Igal Tabachnik: So I will kind of make a jab at Ali that he's the he's the AI person in the company, because the amount of time he spends explaining things to Chatgpt. It's amazing. But I will mention this from from my perspective, as somebody who's like a developer that's being introduced to AI assisted tools. So

291 00:55:42.200 --> 00:55:53.800 Igal Tabachnik: I'll skip to the end. Today I'm preferring to use mostly coding agents, such as Claudecod, and recently a new tool called Amp. From

292 00:55:54.180 --> 00:55:56.380 Igal Tabachnik: I always forget the name

293 00:55:57.030 --> 00:56:22.470 Igal Tabachnik: sourcegraph, which is a company that also they make products for understanding and analyzing and navigating code a lot so. But now they came up with their own agentic. AI. And this is something that's really that took an incredible kind of it exploded with incredible rate in the past couple of months, really from my perspective.

294 00:56:22.710 --> 00:56:34.319 Igal Tabachnik: But to to go back to AI 1st when Google's co-pilot was introduced. Yes, it was nice. It was kind of a predictive code completion thing. So

295 00:56:34.320 --> 00:56:55.570 Igal Tabachnik: many people enabled it, as long as they didn't have to pay for it. So after it became a paid product, some people stayed with it. Some people didn't. I had value from it, because when I was working with Scala it helped me to fill in the boilerplate. Scala does have some boilerplate that you have to do, and so I paid out of my own pocket

296 00:56:55.690 --> 00:57:00.830 Igal Tabachnik: initially for Github copilot, just to keep it working

297 00:57:01.230 --> 00:57:14.799 Igal Tabachnik: and to keep churning up this boilerplate. Eventually we switched to a company subscription, and then the tools became smarter and smarter, and I started to realize that they do

298 00:57:15.040 --> 00:57:34.220 Igal Tabachnik: understand your code better every time. So they keep this context. I needed an explanation from the Resident AI expert, Ellie. He needed to explain to me how what are tokens and how all of this stuff works. And it's it's really, truly incredible how Llms essentially are built.

299 00:57:34.960 --> 00:58:04.160 Igal Tabachnik: But the idea, the idea there is that the more context you have, the more code of your own you can shove into the AI the better results the better predictions you're going to have. And predictions are what AI's do. They do not understand the code themselves. They understand what is the next likely token to emit, so most likely they will emit the correct thing. And so over the months over the last, I don't know. Maybe a couple like

300 00:58:04.210 --> 00:58:10.089 Igal Tabachnik: I want to say 5 or 6 months that I've been using AI with rust, I see much less

301 00:58:10.370 --> 00:58:31.970 Igal Tabachnik: almost none of hallucinations that typically come with with using Llms. So, for example, Llms, like even like copilot, or or even tools from Chatgpt. They don't necessarily. When they don't know something they will just make something up. They will make Api that does not exist, and they will. They will just suggest you to do things that that are just

302 00:58:32.080 --> 00:58:33.859 Igal Tabachnik: impossible, for example.

303 00:58:34.080 --> 00:58:46.399 Igal Tabachnik: And since switching, trying different models, and and lately I've been using Cloud's model a lot sonnet 3.7. And then. Now last week they released 4.0.

304 00:58:46.940 --> 00:59:10.759 Igal Tabachnik: And so ever since switching to that, I've been seeing, much less hallucinations. And it really does solve the issues. And also in a way that's straight to the point. No, not too many explanations. But then they just give me actionable solutions to, for example, compilation errors, or sometimes they just want to. For example.

305 00:59:10.940 --> 00:59:38.189 Igal Tabachnik: let's see, I just, for example, even I want to to create a struct that derives whatever debug and clone it. Just sometimes, instead of typing out the struct the code, I will just type create a struct for whatever deriving all these things, and it will just think for 2 seconds and just do it for me. So yes, I find AI used to be an incredible assistant, and I do think that we are at least in the beginning of

306 00:59:39.150 --> 00:59:42.900 Igal Tabachnik: I don't even I don't even want to say paradigm shift, because

307 00:59:43.140 --> 00:59:55.960 Igal Tabachnik: I think it's too big of a too big of a term for this. But I really don't remember anything kind of anything like this in in the recent years that that also explodes in

308 00:59:56.230 --> 01:00:08.099 Igal Tabachnik: in in the way that what's the word I'm looking for kind of improves every single time every week. There's some sort of marginal, some sort of major improvement that just

309 01:00:08.750 --> 01:00:14.759 Igal Tabachnik: I wouldn't. I wouldn't. I don't know if I would be able to go working without AI assisted tools anymore.

310 01:00:15.050 --> 01:00:20.020 Igal Tabachnik: because it's just when you figure out the flow. It's just a huge time saver.

311 01:00:20.140 --> 01:00:28.180 Igal Tabachnik: for example, I do. Instead of Googling. I don't remember the last time I googled anything. I use perplexity, which is another AI kind of

312 01:00:28.290 --> 01:00:56.580 Igal Tabachnik: kind of AI aggregator that does searches for you and scans many websites and gives you actionable to-do lists. So every time I need to search for something, I don't go Google it. I just go to perplexity or sometimes chat gpt when I need the dialogue, and I find myself using using it more and more. Now, of course, all of these tools cost money, and I'm sometimes happy for my personal use. I'm happy to pay for these things because I do get the value from them.

313 01:00:56.670 --> 01:01:16.760 Igal Tabachnik: It wasn't like that, with many kind of developer assisted tools. Funnily enough, Ellie and I used to work for a tooling company and selling tools to other developers is very hard. Tooling companies are notoriously difficult to sell like one. The biggest kind of success I can think of is probably Jetbrains.

314 01:01:16.890 --> 01:01:19.869 Igal Tabachnik: which which is able to sell ids.

315 01:01:20.000 --> 01:01:24.850 Igal Tabachnik: But there are now talks about ideas being a thing of the past.

316 01:01:25.460 --> 01:01:33.830 Igal Tabachnik: Now, whether or not it's a hyperbole I don't know, but I do find many, many compelling reasons to

317 01:01:34.300 --> 01:01:57.649 Igal Tabachnik: shift the loop to outside of the Id. The Id is there to just read through the code, maybe use some syntax highlighting and do maybe analyzing of the work that was done, but the main part of the work is being done by AI, which is exciting and scary at the same time. I'm sorry I kind of went into answering

318 01:01:57.860 --> 01:02:07.440 Igal Tabachnik: other imaginary set of questions, but but that's that's where I stand. I really like AI, and I do feel that it brings a lot of value to my day to day.

319 01:02:09.640 --> 01:02:11.689 Gabor Szabo: Andy, would you like to add add something to this.

320 01:02:12.000 --> 01:02:26.939 Eli Shalom: So one thing, which is, was one of the pains a year ago. So when we started working with rust and chatgpt, and we felt with both of us, my partner and I don't know rust. We coded a lot in rust, but we don't know rust.

321 01:02:27.060 --> 01:02:47.020 Eli Shalom: which was the 1st language I encountered this. It's also the 1st language I learned after the explosion of Llms. So this was like something which was very troubling, and less than a year after that. And so today was the 1st time I had a ticket which was done solely by an agent.

322 01:02:47.030 --> 01:02:57.879 Eli Shalom: So my whole thing, my whole work in the ticket was just to copy paste the the Jira ticket into Amp code, and that's it. And the implementation was the right. In the 1st place.

323 01:02:58.380 --> 01:03:00.220 Eli Shalom: it went online.

324 01:03:00.560 --> 01:03:05.040 Eli Shalom: Even, we have an AI in Github which also reviews the Pr.

325 01:03:05.160 --> 01:03:10.389 Eli Shalom: It gave a small comment, fixed it by itself. And that's it. I didn't do anything in the ticket

326 01:03:10.510 --> 01:03:34.190 Eli Shalom: other than copy pasting the the Jira ticket into the into the prompt. This was something which was exciting, so I still don't know. How do I feel about the worry from last year we but I want no rust, because I don't know rust. Well, probably there are many, many good developers who do it way better than me. But

327 01:03:34.390 --> 01:03:42.630 Eli Shalom: maybe I don't need to know rust that well in the future, because an agent will complement everything which I don't know how to do.

328 01:03:42.870 --> 01:03:43.840 Eli Shalom: So

329 01:03:44.240 --> 01:03:54.539 Eli Shalom: I wonder what will be the the conclusion in a year or 2 from now. But it's a very different experience than anything in the previous 2 decades. In coding.

330 01:03:57.220 --> 01:04:04.529 Gabor Szabo: Very interesting. So I'm not sure if the next question is even relevant anymore. I wanted to ask you.

331 01:04:04.650 --> 01:04:11.599 Gabor Szabo: I'm guessing, or I was guessing earlier that you're looking for more developers being a startup.

332 01:04:12.050 --> 01:04:15.900 Gabor Szabo: And then I wanted to ask you, okay, what would

333 01:04:16.030 --> 01:04:22.909 Gabor Szabo: a person who wants to apply to or or get picked up by you.

334 01:04:23.640 --> 01:04:38.950 Gabor Szabo: What could what should they invest in in if they had like one month now to prepare, or 1 2 months to to be a better candidate for you. But I am wondering now, do you even really need more people, or you're just

335 01:04:39.340 --> 01:04:43.590 Gabor Szabo: sit down, ride the tickets, and then you click 2 buttons, and it's done.

336 01:04:43.590 --> 01:04:46.150 Igal Tabachnik: The official term for this is vibe coding.

337 01:04:46.340 --> 01:04:47.040 Gabor Szabo: Yeah.

338 01:04:47.040 --> 01:04:49.540 Igal Tabachnik: Semi-official.

339 01:04:49.810 --> 01:04:50.570 Igal Tabachnik: Yep.

340 01:04:50.890 --> 01:05:15.139 Eli Shalom: So there is a very good question regarding this. So there's 1 thing, but many tickets are still very hard to develop. They're conceptually hard algorithm behind them to implement are not the trivial, and they're new by nature, and I believe it. An agent or any of them won't be able to implement them end to end at the beginning. So someone with deep understanding of

341 01:05:15.370 --> 01:05:29.939 Eli Shalom: coding engineering infrastructure will still be very relevant. And there's something which Eagle uses a lot when we're talking about rust developers, they're self selecting. So not many people go to learn and develop in rust by themselves.

342 01:05:30.090 --> 01:05:42.489 Eli Shalom: And like, probably I'm an exception, because I didn't have to choose it last. Chose me. But many people just go there and and and decide they want to be Russ. And usually these are people with a great

343 01:05:42.560 --> 01:05:52.600 Eli Shalom: passion for coding internals. Understanding. It's not a language we people come because it's very elegant, or the code looks very nice in the syntax.

344 01:05:52.660 --> 01:06:20.370 Eli Shalom: so I guess one of the things is that people who want to join the team are people who really really love rust and have passion to it, and want to learn more of it and do a lot. Another aspect which is probably unique to us is that the context of ethereum development is also quite challenging, because practically what we're doing is we're developing or working on something which executes a code of another, of

345 01:06:20.410 --> 01:06:35.029 Eli Shalom: of another virtual machine of another language. So one of the things which are very important are people who also like coding in general, and some experience in ethereum is very helpful like to understand the Protocols, how it works, how the virtual machine works.

346 01:06:35.080 --> 01:06:40.820 Eli Shalom: It gives a lot of advantage and reduces a lot of the pain in the work.

347 01:06:41.320 --> 01:06:56.140 Gabor Szabo: Okay? So I guess the answer would be, now that okay, so if there is a rust developer and she or he wants to join your team because they really like the idea. Then they should invest in learning at their own, and and try to

348 01:06:56.380 --> 01:06:58.719 Gabor Szabo: learn that, for example, right.

349 01:06:58.720 --> 01:07:01.000 Eli Shalom: Yeah, that's 1 of the things which helps most.

350 01:07:01.000 --> 01:07:06.730 Gabor Szabo: Okay, that's sort of like the internal things would, would

351 01:07:07.050 --> 01:07:25.100 Gabor Szabo: would like contributing to open source project. Be something that you look at the people. So if I go and contribute to open source projects, would that be something like a good point for me, or you don't care about that too much?

352 01:07:25.300 --> 01:07:38.319 Eli Shalom: So we give it a little bit of good points, especially to anyone who works in open source. It reflects something of the excitement and passion of the of the developer. But the main thing we saw that, like real experience, like

353 01:07:38.640 --> 01:07:53.309 Eli Shalom: having been post, the fight of the borrow checker is usually where people have more advantage with their experience. So some experience in real work with rust is is the thing we will mostly looking for.

354 01:07:55.720 --> 01:08:09.910 Gabor Szabo: Okay. And then, finally, I would like to change a little bit the direction of the audience. And, by the way, we didn't have any question from the audience. So the people who are present. So if you would like to ask anything, just please type in chat.

355 01:08:10.100 --> 01:08:11.210 Gabor Szabo: Awesome.

356 01:08:13.780 --> 01:08:31.690 Gabor Szabo: But I wanted to ask. That means, from my point of view, the last question we are still waiting for the for the guest is to the audience of other managers or entrepreneurs who try to set up their own startup company.

357 01:08:32.590 --> 01:08:33.690 Gabor Szabo: How would you?

358 01:08:34.189 --> 01:08:37.149 Gabor Szabo: What would you tell them when, when selecting

359 01:08:37.350 --> 01:08:40.720 Gabor Szabo: rust or not rust? I mean for you. It was a little bit

360 01:08:41.540 --> 01:08:52.639 Gabor Szabo: less of a choice, though you did try, python, but what what point should they consider? Better to use rust or not?

361 01:08:53.229 --> 01:09:05.659 Eli Shalom: So from my point of view, the main challenge is the lack of talent. So there are very few people, and locally, but also globally, and we've enough experience in in rust

362 01:09:05.759 --> 01:09:25.809 Eli Shalom: and men. And because a lot of those people joined many startups, especially in the in in our area, in blockchain companies. So the and the fight and competition over over talent is is very difficult. So it means that it's going to be a price that the startup is going to pay. So

363 01:09:25.859 --> 01:09:48.229 Eli Shalom: if a startup can choose to take a different language like a simpler one, even C-shop, then the chance to finding developers more easily is significantly higher, and going with rust means that at least for the next year or 2, and getting talent is going to be challenging.

364 01:09:48.369 --> 01:10:04.939 Eli Shalom: So that's the main thing. I'd say we like the language. We found that the ecosystem is rich enough to support almost everything we need. So it's like very like that. We it fills everything we need. Just we don't have enough people to

365 01:10:05.029 --> 01:10:25.899 Eli Shalom: we to be honest. We just managed to hire all the people we needed for the team, but it was we had to sweat a lot, for it was more challenging than we expected, and also I'm not sure that in regards to choosing it as a language to just a general back end and

366 01:10:26.139 --> 01:10:31.279 Eli Shalom: service system. I'm not sure that that's the right language to use like more

367 01:10:31.499 --> 01:10:40.379 Eli Shalom: infrastructure, like processes, things with which needs to work with high load probably justified a little bit better.

368 01:10:41.230 --> 01:11:03.209 Igal Tabachnik: Yeah, I actually do want to add, because I think we kind of discussed this question ahead of time. And also me personally, I was responsible. In the previous company I was responsible for training and mentoring Scala developers. Now Scala and Rust are pretty much in the same boat, with regards to scarcity of talent.

369 01:11:03.320 --> 01:11:22.239 Igal Tabachnik: It's a difficult language to pick up. And and and there are many, many way way. Kind of more forgiving languages out there. So why, why specifically rust, or why specifically, Scala. So I guess if you have needs now again rust was developed. So I'm going to say like

370 01:11:22.680 --> 01:11:46.709 Igal Tabachnik: 2 things. 1st of all, if you don't have ras talent and and but you really need to. You can hire, and you. You should hire quality engineers with a good resume and good kind of yes, open source. Open source contributions are always kind of welcomed. But we're generally looking for people who creative thinkers and problem solvers and and people who can, just

371 01:11:46.710 --> 01:11:55.199 Igal Tabachnik: they know how to learn things, and I am pretty sure they can pick up any language fast.

372 01:11:55.400 --> 01:12:10.420 Igal Tabachnik: So the goal is, make your own kind of invest. So this is what we're trying to do. We're trying to also invest in training resources in material for making our own rust developers eventually.

373 01:12:10.530 --> 01:12:17.490 Igal Tabachnik: whether or not we need to buy books or or courses, or do internal kind of sessions and and stuff like that. So

374 01:12:17.510 --> 01:12:46.230 Igal Tabachnik: this is all part of the growing of the company that all companies in early stage should invest in. But I will say, however, the negative, if there's 1 kind of why not pick rust is exactly like Eddie mentioned. I think that if your primary product is just a back end web server, you need to handle like web requests or serve websites. I might think that rust

375 01:12:46.450 --> 01:13:14.219 Igal Tabachnik: might be a slight overkill for that. Yes, you can. You can use an Http framework and serve it. But there's going to be way. Too much friction for getting things done quickly. I mean, you would much rather have a Jvm. Based language like Kotlin or Scala, obviously, or even typescript. There are many, many great big companies that do backends on typescript today, and it just works. And it's very, very fast, I would say, if you're a company that develops servers.

376 01:13:14.500 --> 01:13:43.670 Igal Tabachnik: products like that have to run and serve a lot of connections and a lot of be under high loads all the time. Things like Redis, for example, which is also written in rust, or being rewritten in rust. There are many other companies that I know that develop these tools, or if you primarily need to work on a commodity or a commodity hardware. For example, if you need to deploy products like browsers, for example, to end customers

377 01:13:43.730 --> 01:13:55.769 Igal Tabachnik: who might not have very fast machines. You might consider a language like rust or a native language that will compile to a small executable, and be very, very fast.

378 01:13:55.930 --> 01:14:07.660 Igal Tabachnik: But of course you could pick a language like C sharp for that. Again, there are. There are trade trade-offs in in many of them, from my perspective and kind of to. To conclude this.

379 01:14:07.940 --> 01:14:09.759 Igal Tabachnik: I would say, it's

380 01:14:10.040 --> 01:14:14.730 Igal Tabachnik: in the end you have to decide as a manager, as as an engineering manager. What's kind of

381 01:14:14.890 --> 01:14:21.590 Igal Tabachnik: you have to pick one out of the 2 options, whether you prefer correctness

382 01:14:21.770 --> 01:14:25.259 Igal Tabachnik: or do you prefer well anything else

383 01:14:25.330 --> 01:14:31.819 Igal Tabachnik: like how important it is to to have a bug-free experience for you like. If you place it higher up.

384 01:14:31.880 --> 01:14:51.289 Igal Tabachnik: then you should probably pick a language like rust that will prevent you from having runtime surprises if I say so, if you use it correctly. Of course there's many gotchas in rust like, if you use it incorrectly like, if you unwrap everywhere, which is the wrong way of using rust. But many people do, because it

385 01:14:51.290 --> 01:15:10.150 Igal Tabachnik: it lets them compile the code. So no unwrapping is the exact wrong thing to do. And until people realize that they will be using rust wrong and they won't get any benefit from it. They will see that it's actually it's not protecting them from anything. They will have runtime panics.

386 01:15:10.280 --> 01:15:29.199 Igal Tabachnik: They need to learn to understand that unwrapping is not what you do, for instance, and it's a learning curve, like, like with many languages. I think rust has an additional learning curve, because it introduces a couple of novel ideas that do not exist in many languages, like people coming from Java, or even C, plus plus.

387 01:15:29.320 --> 01:15:40.979 Igal Tabachnik: They don't necessarily know of all of these mechanisms, for, you know, separating data with behavior, for example, derivation or or things like

388 01:15:42.030 --> 01:15:48.610 Igal Tabachnik: even the macro system works would work differently, I suppose, like, I said, there's learning curve you have to invest in it, and

389 01:15:48.810 --> 01:15:52.030 Igal Tabachnik: it's it's a it's a matter of of a trade-off.

390 01:15:52.300 --> 01:16:08.530 Igal Tabachnik: But but the bottom line is that if you make servers, you probably want to look into rust. If you make general backend servers like serving websites, you would likely do better with using a less difficult language to to master.

391 01:16:10.990 --> 01:16:16.950 Gabor Szabo: Okay, thank you very much. I ran out of questions. And

392 01:16:17.050 --> 01:16:30.999 Gabor Szabo: and our audience is rather silent today. And do you have anything else that you wanted to talk about, that you think that I should have asked earlier, and I didn't.

393 01:16:33.340 --> 01:17:00.219 Igal Tabachnik: Well, 1st of all, I just wanted to thank you again for inviting us. This is really fun, and I like to geek out about this stuff. Sometimes it's very difficult for me to stop talking, and so hopefully. The reason there are no questions is that I inadvertently answered them all hopefully or not. We'll find out, maybe from feedback on this episodes when it comes out.

394 01:17:00.350 --> 01:17:01.250 Igal Tabachnik: And

395 01:17:02.060 --> 01:17:13.169 Igal Tabachnik: but but I think we covered a lot. I think the questions were great. And I'm looking forward for this podcast to run for many, many years and have many, many great guests. And

396 01:17:13.210 --> 01:17:33.689 Igal Tabachnik: maybe before we leave, I will provide our socials, and how to reach us. If there are any, follow up questions I would be more than happy to answer even mail or or Twitter X, or even even just a private private zoom. That's also always welcomed. I'm happy to talk about these things.

397 01:17:34.230 --> 01:17:39.800 Gabor Szabo: Okay, sir, you want to say them, or we'll just add them to.

398 01:17:39.800 --> 01:17:45.270 Igal Tabachnik: Maybe I will. She should probably add them, because my my nicknames are weird. I have to spell them out.

399 01:17:45.530 --> 01:17:48.909 Gabor Szabo: Okay, Ellie, you wanted to add something.

400 01:17:49.340 --> 01:18:05.709 Eli Shalom: And so I don't have anything to add, and just have to say that I'm really excited, that a new community of rust is being built and people are attracted to it. It's a very exciting language, very exciting technology being built with it in many projects. And we're very happy that this forum exists.

401 01:18:07.240 --> 01:18:16.319 Gabor Szabo: Well, I I really thank you very much for for being here, and and all kind of really fun, information, and and insight you we got

402 01:18:16.440 --> 01:18:26.519 Gabor Szabo: and thank you for the audience, who was listening silently here and thank you for everyone who is listening, who is listening to the podcast

403 01:18:26.690 --> 01:18:29.589 Gabor Szabo: there are going to be

404 01:18:29.980 --> 01:18:36.770 Gabor Szabo: show notes is all kind of links, so please follow them, and thank you very much. Goodbye. Bye-bye.

405 01:18:36.770 --> 01:18:37.739 Eli Shalom: Thank you. Bye.

• Guest: Ran Reichman Co-Founder & CEO of Flarion
• Host: Gabor Szabo
• Language: English
• Location: Zoom

In this conversation we'll discuss the use of Rust at Flarion.

Ran is co-founder and CEO of Flarion, a company building high-performance data processing systems using Rust.

Prior to Flarion, Ran built high-scale data processing systems in cybersecurity, autonomous vehicles, and cloud infrastructure.

Transcript

1 00:00:02.840 --> 00:00:25.500 Gabor Szabo: Hello and welcome to the Code-maven live meeting. And if you're listening to the podcast then it's supposed to be the rustation station. If everything goes well, then, this conversation is going to be uploaded there as well. My name is Gabor Sabo. I usually help companies with rust

2 00:00:25.800 --> 00:00:45.769 Gabor Szabo: and python, and in this series of of meetings and conversations I try to discuss with guests how the the title is rost at work, so I'm trying to understand how people use rust at work, and

3 00:00:45.980 --> 00:00:51.359 Gabor Szabo: what are the considerations? What are the advantages? Maybe disadvantages? And so on.

4 00:00:51.610 --> 00:00:59.340 Gabor Szabo: And this time the 1st guest is Ron Reichman from Florian, Hi Ron.

5 00:00:59.720 --> 00:01:01.610 Ran Reichman: Hello, yeah. It's great to be here.

6 00:01:02.710 --> 00:01:06.595 Gabor Szabo: Thank you for accepting the invitation, and

7 00:01:07.530 --> 00:01:17.960 Gabor Szabo: let's get started. I think the 1st thing should be is that you you introduce yourself. We actually never met. So it's gonna be a 1st for me as well.

8 00:01:18.450 --> 00:01:25.170 Ran Reichman: Okay, excellent. Yeah. So thanks again for for having me here and excited for this chat.

9 00:01:26.269 --> 00:01:46.930 Ran Reichman: I'm Ron Reichman, a co-founder, and CEO with clarion. And what we do is at Clarion is we're a data processing company building solutions to accelerate and make data processing much more efficient, especially at large scale of the big data which means usually like

10 00:01:47.928 --> 00:01:53.750 Ran Reichman: terabytes, tens of terabytes, hundreds of terabytes. But we support a wider range of workloads.

11 00:01:53.930 --> 00:02:01.579 Ran Reichman: And yeah, we're definitely a rust shop and lots to talk about in terms of why rust, how we use rust, etc.

12 00:02:03.090 --> 00:02:14.739 Gabor Szabo: Can. Can you tell a little bit about your about your background? And this is a startup company, right? How long, how long? How long is the company? And what did you before? And how did you get there? That's that's sort of the.

13 00:02:16.080 --> 00:02:31.519 Ran Reichman: Yeah, it's a great question. So I'm born and raised in Israel and in the army. I was in the program which has recently become more famous, thanks to the whiz founders that are also graduates spent about 8 years

14 00:02:31.730 --> 00:02:37.570 Ran Reichman: in various intelligence units, low level development stuff like that.

15 00:02:38.384 --> 00:02:51.085 Ran Reichman: Then went on to work on a on a news startup briefly, and then spent about 4 and a half years in the in the United States and working on

16 00:02:51.900 --> 00:02:56.640 Ran Reichman: on autonomous vehicles and on cloud infrastructure.

17 00:02:57.424 --> 00:03:04.729 Ran Reichman: So I had a chance to work at Roblox, which has a data at a very significant scale, and before that, at embark trucks.

18 00:03:04.950 --> 00:03:09.610 Ran Reichman: and for the past 2 and a half, 2 years or so I've been working on what is now clarion.

19 00:03:11.050 --> 00:03:11.715 Gabor Szabo: Okay,

20 00:03:12.540 --> 00:03:18.980 Gabor Szabo: So it's flaring is is 2 years. And and when did you start using rust? Or when did you get

21 00:03:19.140 --> 00:03:26.519 Gabor Szabo: to start? Yeah with rust. Was it in Florian, or or already you started to use rust earlier.

22 00:03:27.520 --> 00:03:39.599 Ran Reichman: So I'm my. My background is C, plus, plus. I have a ton of ton of experience with the C plus plus. And when I started building Clarion. I knew that I was that I was interested in in using rust.

23 00:03:40.009 --> 00:03:46.669 Ran Reichman: Because primarily, I mean, there's there are several reasons that we can go into, but that that's when I started going.

24 00:03:48.270 --> 00:04:06.279 Gabor Szabo: Yeah, I'm definitely interested in in in. Why did you start? Why did you think that is good for for this company? And this is a startup company. So one of the things that I hear sometimes that it's not maybe not such a good language for startups.

25 00:04:09.420 --> 00:04:32.499 Ran Reichman: Yeah. So I I would disagree. I think I think it's a good language for startups. I'd say 3 main reasons that we're using spark that we're using rust here at the flare on the 1st is we're connecting to existing data infrastructure for our customers, and our customers have a very high expectations in terms of reliability.

26 00:04:33.603 --> 00:04:36.929 Ran Reichman: So it's a

27 00:04:37.596 --> 00:04:46.779 Ran Reichman: it's a it's a quite a significant advantage. The fact that we don't really have to worry about the memory, memory, corruption, and everything that that entails.

28 00:04:47.090 --> 00:04:49.459 Ran Reichman: so that that that was one thing

29 00:04:50.017 --> 00:05:06.560 Ran Reichman: the second is, there's quite a lot of interesting infrastructure today in the rust world. There's also a lot of great stuff in C, plus plus. But things like polars, like data fusion. These are open source projects that we were happy to plug into and integrate with.

30 00:05:06.760 --> 00:05:31.820 Ran Reichman: And the 3, rd which is an interesting one is that we kind of like the people who are into rust. So what we do at flare on is kind of it requires a lot of out of the box, thinking it requires trying out new systems, new ideas, and oftentimes the kind of people the kinds of people that are interested in the working in rust are also the kinds of people that we want to have at Larry on. Those were the 3 main reasons.

31 00:05:33.550 --> 00:05:34.460 Gabor Szabo: Okay.

32 00:05:34.520 --> 00:05:55.609 Gabor Szabo: Before I go, continue with this. Actually, I would like to ask something about this. I would like to mention that, unlike other podcasts or conversations, or whatever we have here, where there's only 2 people speaking here, we have a few other guests who are watching us and listening to us.

33 00:05:55.610 --> 00:06:13.769 Gabor Szabo: and I would like, and though they can't speak, but they can definitely ask questions in the chat. So I would like to invite everyone who is present that if you have any questions, just type in the question, and I'm going to take care, and we are going to. I'm going to ask those questions here as well.

34 00:06:13.790 --> 00:06:20.239 Gabor Szabo: So here already we have the the 1st questions from the from the audience is, Have you considered other languages.

35 00:06:21.470 --> 00:06:26.619 Ran Reichman: Yeah. So my, my, I definitely considered other languages. The default for me was to use the C plus plus

36 00:06:28.390 --> 00:06:42.050 Ran Reichman: I have a lot of good things to say about C, plus plus. I'm definitely not a hater of the language. I think so so much over the existing infrastructure. Of the of the software world was built on on top of C, plus plus

37 00:06:42.532 --> 00:06:49.617 Ran Reichman: but yeah, I think the 3 the 3 reasons that I mentioned or pushed us towards Ross.

38 00:06:50.730 --> 00:06:52.339 Ran Reichman: but yeah, and.

39 00:06:52.340 --> 00:07:08.300 Gabor Szabo: Okay, I'm actually especially interested in the 3rd one that you mentioned of the the type of people. I think that was the the 3rd one. So can you describe what? How would you describe this this type, or how do they? How do they differ from? I don't know

40 00:07:08.480 --> 00:07:09.360 Gabor Szabo: others.

41 00:07:10.050 --> 00:07:20.130 Ran Reichman: Yeah, so any generalization is wrong. Right? So there there are. It's it's hard to categorize people for sure. But what we've seen

42 00:07:20.240 --> 00:07:43.149 Ran Reichman: is that when people are curious about rust they're usually just curious people. They hear about a new technology, and they want to understand it better. And they want to try it out, and they wanna explore it. And we're a company fundamentally what we do like if if we zoom out is we look at it as like receiving high level instructions

43 00:07:43.753 --> 00:07:47.960 Ran Reichman: from our customers like this is what I wanna achieve with my data.

44 00:07:48.280 --> 00:07:54.179 Ran Reichman: And then under the hood, we, we might use different engines, different technologies, different techniques.

45 00:07:54.741 --> 00:08:09.439 Ran Reichman: So we're we're we have a very broad stack in terms of things that we need to understand and support. So we really want people who are curious about new technology and want to adopt a different and interesting technologies. Yeah.

46 00:08:10.460 --> 00:08:18.469 Gabor Szabo: Okay. So there's another question here which is actually jumping a little bit ahead, asking about Flurry and and get on, Github, which

47 00:08:18.960 --> 00:08:26.850 Gabor Szabo: it was sort of planned to be that I asked later on whether any of any part of Florian is open source.

48 00:08:27.330 --> 00:08:30.509 Gabor Szabo: and and if if he has done, where is it?

49 00:08:30.760 --> 00:08:31.890 Gabor Szabo: Hey? Welcome.

50 00:08:31.890 --> 00:08:32.789 Ran Reichman: Yeah, so

51 00:08:33.679 --> 00:08:51.449 Ran Reichman: excellent question. We're huge fans of open source. And we also build on top of open source. We don't currently have a public repository. We do, do a lot of contributions particularly to projects like a data fusion and arrow

52 00:08:52.087 --> 00:08:59.859 Ran Reichman: so that that's mostly our involvement in open source that like, we were heavy users of existing technologies. And we're able to push them to the limit

53 00:09:00.060 --> 00:09:13.719 Ran Reichman: and find interesting bugs, edge cases, etc. And yeah, and unpack them, unpack them, debug them and issue pull requests. So we have. We have quite a bit of those in the in the open source. Ecosystem.

54 00:09:13.720 --> 00:09:42.949 Gabor Szabo: If you're already started to go in this direction, then I have a few more questions, because I mean you mentioned 2 major projects that you're rely on major open source projects. But I guess you have tens, or maybe hundreds of of rust crates that use. And if you think about all the hierarchy that maybe thousands. And I'm really interested in. How do you deal with all the dependencies, the

55 00:09:43.550 --> 00:09:46.289 Gabor Szabo: all the problems that come with the dependencies.

56 00:09:47.620 --> 00:10:00.109 Ran Reichman: Yeah. So I don't think there's a good solution to this, like one of the challenges with rust, which isn't necessarily unique to us. But it's very you can feel it very strongly when you're building a a big rust project is

57 00:10:00.892 --> 00:10:21.569 Ran Reichman: the number of crates that grows quite rapidly you start with like 50. And then you're at 150. It's only 500. So yeah, definitely, lot of lots of dependencies. We invest in the Ci infrastructure so that the build is as fast as possible. We we're constantly maintaining

58 00:10:21.720 --> 00:10:24.008 Ran Reichman: the like the whole

59 00:10:25.040 --> 00:10:31.749 Ran Reichman: build set up in order for it to be as quick as possible. Sometimes. That also means using like powerful servers

60 00:10:32.212 --> 00:10:36.077 Ran Reichman: but I don't think there's a silver bullet here in terms of

61 00:10:36.812 --> 00:11:01.139 Gabor Szabo: What? Yeah. What I'm interested in is, how do you select crates? How do you make sure that they are? How how much can you invest in, or how much do you invest in verifying that they are secure enough that they performant enough? And how do you deal with with bugs, or any issues in these these crates.

62 00:11:02.440 --> 00:11:11.110 Ran Reichman: Yeah. So if if we encounter a a, we're quite picky so if if something is small enough, then we won't take a crate, but actually implement it.

63 00:11:11.574 --> 00:11:17.419 Ran Reichman: But in terms of bugs and reliability. So that's the that's the thing that I think we we invest more than anything else

64 00:11:17.740 --> 00:11:19.719 Ran Reichman: in terms of just like

65 00:11:20.614 --> 00:11:28.730 Ran Reichman: we really have tons and tons of tests to make sure that reliability is that is really as close as possible to 100%

66 00:11:30.390 --> 00:11:36.083 Ran Reichman: And that also is the case. When we introduce new crates, like, we're also we're we're we have

67 00:11:36.540 --> 00:11:56.890 Ran Reichman: a very expensive suite of testing for that in terms of a a security that's mostly a matter of reputation, like we don't choose crates that we think will do a bad job for us or that were that are shady. We look at like number of downloads. Are people using this in the ecosystem stuff like that?

68 00:12:00.420 --> 00:12:02.709 Ran Reichman: Yeah, I think that's mostly it.

69 00:12:03.020 --> 00:12:04.909 Gabor Szabo: Have you? Have you

70 00:12:05.070 --> 00:12:16.720 Gabor Szabo: considered or tried, or do you think that there is a need of financing, sponsoring certain open source developers who are

71 00:12:16.960 --> 00:12:26.660 Gabor Szabo: unrelated to your company, who maintain these these packages, or or bug bounties, or things like this.

72 00:12:27.540 --> 00:12:30.942 Ran Reichman: Yeah, I I completely, I think,

73 00:12:31.620 --> 00:12:35.570 Ran Reichman: I think companies like us should definitely invest in these kinds of things.

74 00:12:36.193 --> 00:12:39.720 Ran Reichman: We haven't yet detected like a

75 00:12:40.000 --> 00:13:02.590 Ran Reichman: the right projects in terms of the ones that we're actually heavily using and in need of these resources. Because we're pretty in the mainstream, like lots of Apache stuff, like lots of stuff that's already has a lot of investment. But yeah, if we encounter something that we can contribute to or even contribute financially, definitely, something that we'd consider. We we want the ecosystem to be sustainable.

76 00:13:03.920 --> 00:13:28.949 Gabor Szabo: Okay. So I think we can go back to to the mainstream sort of of this conversation. But actually, there are questions here that sort of related to this, which let me read it, because that's easier. Also, could you please elaborate a bit more on the nature of rust in your use case, what do you mainly do with rust? Do you use Asyncrust?

77 00:13:30.480 --> 00:13:33.583 Gabor Szabo: Yeah. So great question.

78 00:13:34.680 --> 00:13:42.290 Ran Reichman: The the nature of our use of rust is we use rust, basically in all of the data processing that we that we do

79 00:13:42.792 --> 00:13:50.970 Ran Reichman: so the way our system works is that we connect to existing infrastructure. So it can be something like written in Scala, for instance, Apache spark

80 00:13:51.885 --> 00:13:58.399 Ran Reichman: or in python and some of the ray infrastructure. And once we pass on

81 00:13:59.141 --> 00:14:05.909 Ran Reichman: the responsibility of the data processing from the high level language to a rust.

82 00:14:06.340 --> 00:14:18.049 Ran Reichman: We do everything in rust. We use a Jni when it's a Java virtual machine, and and python, we also use the relevant bindings to pass from

83 00:14:18.500 --> 00:14:28.769 Ran Reichman: from python to rust. And then it's basically rust all the way until we we have to give back the some sort of result. And then and then send it back.

84 00:14:29.470 --> 00:14:36.040 Gabor Szabo: So besides rust, what are what other languages do you use? Separate.

85 00:14:36.040 --> 00:14:37.139 Ran Reichman: Yes, we we use.

86 00:14:37.140 --> 00:14:42.359 Gabor Szabo: Python and and but I don't know if you're using actually or just somehow connecting.

87 00:14:42.360 --> 00:14:47.319 Ran Reichman: We're mostly connecting like we're using Scala and Python Scala more than python

88 00:14:47.896 --> 00:14:51.089 Ran Reichman: because of its use in Jvm environments.

89 00:14:52.790 --> 00:14:53.930 Ran Reichman: And

90 00:14:54.420 --> 00:15:06.250 Ran Reichman: but whenever we can implement something that's that requires performance, we do. We do it in rost. And that's most of what we do requires a a pretty significant performance investment.

91 00:15:08.060 --> 00:15:20.129 Gabor Szabo: Okay, so we can now circle back to the to the beginning of the company, and how rust was introduced to the company, and how and and how you

92 00:15:20.600 --> 00:15:35.980 Gabor Szabo: find new employees. I mean, this was a startup company. So there were. There was no one there. So it's not like a company where you have to start teaching people rust or so. It's totally your decision. If you are bringing in people with rust experience or

93 00:15:36.120 --> 00:15:40.115 Gabor Szabo: without, and then teaching them, how was that process?

94 00:15:40.850 --> 00:15:46.509 Gabor Szabo: What kind of people arrived? They were? Were they already experienced in rust.

95 00:15:47.640 --> 00:15:51.330 Ran Reichman: Yeah. So most of the people we hired are experienced in rust

96 00:15:52.128 --> 00:16:12.230 Ran Reichman: they have. sometimes that means just a general like generally, like as a hobby, have built things in rust. There's some crypto aspect because of the success of the Solana as a blockchain, so that that spurred a lot of rust development

97 00:16:12.762 --> 00:16:20.679 Ran Reichman: so we have a bit from there. And there are a few people who don't really have a rust background, but are a strong C plus plus developers.

98 00:16:20.870 --> 00:16:23.070 Ran Reichman: And there we were able to.

99 00:16:26.037 --> 00:16:46.762 Ran Reichman: there, there! It's more of a an investment as a startup. We don't do a lot of training. But if someone in our interview process shows potential and is able to learn rust relatively quickly, then we. We also consider those people. And we have a few of those. I'll say that

100 00:16:48.140 --> 00:16:58.174 Ran Reichman: we try just as a as a philosophy not to push rust to the limit in terms of performance. We push it to the limit in terms of

101 00:16:58.640 --> 00:16:59.560 Ran Reichman: and

102 00:16:59.990 --> 00:17:12.010 Ran Reichman: low level implementations, and we push it to the limit. But we don't like we don't try to be too sophisticated or too clever with the language. That's kind of my experience with C plus plus as well that like, it's possible to be very.

103 00:17:12.190 --> 00:17:33.960 Ran Reichman: very smart and very clever, but sometimes that makes the code harder to maintain. So if if one of you took a look at our code base, you'd see that it's it's mostly straightforward. And when we're doing something that's elaborate, it's usually because that was the last resort. And that's kind of my philosophy, regardless of rust, but especially in rust. Because you you can do a lot of very sophisticated stuff.

104 00:17:35.790 --> 00:17:47.790 Gabor Szabo: Can you elaborate a bit more? What are these things that you feel that there are too sophisticated, or or that you would like to that you're avoiding in in this case.

105 00:17:48.830 --> 00:17:50.340 Ran Reichman: Yeah. So I think,

106 00:17:52.090 --> 00:18:02.329 Ran Reichman: I mean, not. Not all of these are necessarily sophisticated, but the they add complexity. So when it comes to handling channels. Async. Things things in that area.

107 00:18:03.990 --> 00:18:31.159 Ran Reichman: sometimes sometimes. You have to use it. But if you can, if you can be like single core, running very powerfully and achieving your goals. Then we prefer that when it's possible that that's kind of the things that we're looking for. So anything that's like, I mean, this is this is the way in computer science generally, right? Like, once, once you introduce concurrency of various forms. Then things. Things become much more complicated the way when we can avoid that, we avoid it.

108 00:18:32.520 --> 00:18:59.869 Gabor Szabo: Right? So there was a question here that I'm not sure that too relevant to you. But maybe you have some input on this. So how easy for you to recruit developers! Our company is mostly C plus plus and python. And when I introduced Rust Code into the Python group for performance. I saw a lot of resistance from the developers, so I know that it's probably not, really. You haven't probably encountered this, but.

109 00:19:00.310 --> 00:19:08.610 Ran Reichman: I actually have some relevant experience, because I've I've interviewed a lot of people with C plus plus background. And I think there's a there's a divergence there are people who

110 00:19:09.303 --> 00:19:24.626 Ran Reichman: who really love c plus plus really appreciate what it's able to bring to the table. And they don't wanna switch to another language. And when we encounter those in our recruiting process, then we don't try to convince them, because they love what we're doing, and we're not doing what they're doing. And that's great

111 00:19:25.030 --> 00:19:33.180 Ran Reichman: and that that really, I think when when you're in an existing company and you want to introduce rust. I think. Actually, the Linux kernel

112 00:19:33.630 --> 00:19:36.849 Ran Reichman: did a great job in this regard when they're saying like.

113 00:19:37.070 --> 00:19:40.390 Ran Reichman: you can't, you don't really wanna migrate to rust

114 00:19:41.645 --> 00:19:56.979 Ran Reichman: cause, you really want to just migrate to anything basically in the software world, you wanna gradually add functionality show value. See? See that you're able to provide better, developer experience and improved velocity.

115 00:19:57.130 --> 00:20:01.643 Ran Reichman: and then you can encourage people to move on. But I think

116 00:20:02.190 --> 00:20:18.619 Ran Reichman: so if you're starting a new project. This is also what we're seeing in the data processing world. So if a company is using Apache spark and you say, Oh, no, you should use ray, or you should use duck. dB, usually, it's a tough sell because they're using a certain technology. And they like that technology. And they're proficient in that technology.

117 00:20:18.840 --> 00:20:26.089 Ran Reichman: And it's much easier to say, Okay, we're like in this new new team that's building a new technology from scratch.

118 00:20:26.320 --> 00:20:34.400 Ran Reichman: We can try something new. And I found that throughout my experience, and that that's much easier than moving a system from one technology to another.

119 00:20:34.961 --> 00:20:45.909 Ran Reichman: Yeah, that's also the case, like, regardless of rust and C plus plus like Java, go like golang. All of that stuff like there's there's ton of tons of examples in that regard.

120 00:20:47.520 --> 00:20:56.690 Gabor Szabo: The the people who are so. So you recruited a number of people who who basically didn't know rust, but were interested in in rust as well. Right.

121 00:20:58.663 --> 00:21:05.120 Gabor Szabo: What was their learning, process, or learning resources that you might recommend to to everyone else?

122 00:21:12.360 --> 00:21:17.029 Ran Reichman: I think 1st of all, the the Standard Rust Book.

123 00:21:17.350 --> 00:21:31.880 Ran Reichman: It's a good book. There's a lot of good stuff there. I think I read it cover to cover, like online, obviously. But I think I think when you want to get acquainted with rust and what it has to offer, then that's a good thing to use.

124 00:21:32.722 --> 00:21:39.955 Ran Reichman: I think when you're in learning mode, and you want to understand things, then,

125 00:21:41.140 --> 00:21:52.829 Ran Reichman: AI is quite useful like saying like, Hey, I know how to write this in c plus plus like, how would you write this in rust? And then you say, like, explain to me this decoration. Explain why it's not compiling stuff like that.

126 00:21:53.446 --> 00:22:06.289 Ran Reichman: Like AI has its issues and its challenges. And it's hallucination. But when when you're asking like, basic questions of like, this is what I'm doing. This is what I'm trying to achieve. This is how I know how to do it in Python C, plus. Plus. What have you?

127 00:22:06.400 --> 00:22:19.699 Ran Reichman: Then I found that that to be very effective, and I I do very much believe that it's easier to learn a programming language by doing so. Like reading a book is great, but you only internalize things when you

128 00:22:19.840 --> 00:22:29.000 Ran Reichman: and when you try to build, and the compiler is mad at you, and it's like, no, you can't do that. You can't do that either. You can't do that either, and rust in that sense is very annoying. It's a it's a strict boss

129 00:22:29.641 --> 00:22:34.760 Ran Reichman: but the result is good. The result is one in which you can really rely on the

130 00:22:35.310 --> 00:22:39.499 Ran Reichman: and the accurate accuracy, and

131 00:22:40.990 --> 00:22:45.530 Ran Reichman: the reliability of the result. I think that's kind of a Us.

132 00:22:46.830 --> 00:22:59.520 Ran Reichman: a switch that people need to do when they're moving to rust, and when they're trying out rust that, like the compilation, is hard, like getting things to compile is oftentimes the hard part. Then, when things run. They usually run accurately

133 00:23:00.252 --> 00:23:07.230 Ran Reichman: so that's that. That's what we tell people who are who are starting to learn. We're trying things out.

134 00:23:08.220 --> 00:23:08.970 Ran Reichman: Yep.

135 00:23:10.130 --> 00:23:29.490 Gabor Szabo: Yeah, so I do a lot of training. And my experience is that it's nice to explain things to people. But they actually really learn when they do the practice and when they get feedback for whatever they did, and well in rust the compiler gives a lot of feedback, so I have less work. But

136 00:23:29.660 --> 00:23:39.220 Gabor Szabo: still the human human feedback is nice when when you might already solve the problem. But there are better ways to to write in in the given language.

137 00:23:40.770 --> 00:23:45.740 Ran Reichman: Yeah, yeah, 100%. I also say, I think that once you're in a rush scheme

138 00:23:45.910 --> 00:23:56.859 Ran Reichman: which not everyone is in. And it's kind of a priv privilege. Then more junior members just ask a lot of questions, and our senior members like to like to share and mentor.

139 00:23:56.970 --> 00:23:58.060 Ran Reichman: So

140 00:23:58.511 --> 00:24:14.310 Ran Reichman: sometimes you're like, Well, why is this happening? And people just explain like, this is the philosophy behind how this works. So once you have some sort of a a core of a team that's able to provide these insights. Then continuously growing, it

141 00:24:14.780 --> 00:24:16.490 Ran Reichman: becomes easier.

142 00:24:16.490 --> 00:24:29.740 Gabor Szabo: Yeah. A nice part about this actually is that it's not not just not just the juniors who learn from such interaction, but also the more experienced people who encounter interesting

143 00:24:30.200 --> 00:24:45.140 Gabor Szabo: code snippets from the juniors. And then they have to have to think about why these people, why, that person wrote that kind of code. And and what's the story behind it? So I think it's it's in bi directional learning. There.

144 00:24:45.400 --> 00:24:51.879 Ran Reichman: Yeah, I think I think that's true about mentoring in general, like as a mentor, as a professor, as a teacher, you, you learn a lot from your students.

145 00:24:53.490 --> 00:24:55.330 Ran Reichman: I feel the same way as a manager.

146 00:24:56.880 --> 00:25:22.669 Gabor Szabo: Okay. So there is a question here which is actually very close to what I wanted to ask. But let's ask this 1 first.st So do you have any suggestion for someone who would like to find work in rust? Well, see, and other things, and is comfortable with them, but only has web, dev experience, career, wise career, wise. The transition seems borderline impossible.

147 00:25:24.830 --> 00:25:46.349 Ran Reichman: Yeah. So I I understand the sentiment of the comment. It's it's definitely not easy. Because the companies look at your background. And if your background doesn't seem related to what you're looking for I mean the the inconvenient truth is that it's just hard to break through. It's hard to say, like, Oh, yeah, this is this is what I previously did. But what now? I want to do something new.

148 00:25:46.830 --> 00:25:50.715 Ran Reichman: and I I think the

149 00:25:52.780 --> 00:25:59.919 Ran Reichman: they're the main solution to this, and it's not a convenient one, because it requires work. But that's why it's powerful

150 00:25:59.950 --> 00:26:27.659 Ran Reichman: is open source is contributions. Because, like, we have people that we interviewed for the company like we pursued them like we reached out to them that we never met. We don't know what else they did in the world. We just saw the kinds of contributions that they were able to make to interesting projects and say, this is the kind of person we want in the team, and we didn't know that they were like they could be Web Devs. They could be python they could be. I don't know what I honestly don't know what they're doing in their day job.

151 00:26:27.670 --> 00:26:47.530 Ran Reichman: but if you see people if they have like, it's kind of in that sense like art. So if someone shows you their art and the art is beautiful, then you say, like, Okay, I don't really care about the rest. I would like that someone on the team. And it's not easy, because you have to invest. And you have to like, learn and learn these environments, etc. You gain a lot from that. But you have to invest a lot of that.

152 00:26:47.550 --> 00:26:52.829 Ran Reichman: So yeah, not not not the the fast route or the easy route, but one that I think is effective.

153 00:26:53.780 --> 00:27:22.260 Gabor Szabo: Yeah. So so I'm afraid that you already answered my next question. But maybe you can elaborate a little bit more. So let I assume that as a startup you're growing so you're looking for more people. So if I wanted to join your company in the next months, too or so, so I don't have too much time. But let's let's assume I have some background that is relevant to you. What would you suggest to make

154 00:27:22.580 --> 00:27:24.339 Gabor Szabo: to make it

155 00:27:24.570 --> 00:27:35.679 Gabor Szabo: easier for me to to. Yeah, to make it easier for me to to find you or or you to find me, or or okay, whatever right? I think you understand the question.

156 00:27:36.700 --> 00:27:37.200 Gabor Szabo: I hope.

157 00:27:37.200 --> 00:27:39.179 Ran Reichman: Yeah. So 1st of all, the the.

158 00:27:39.180 --> 00:27:48.569 Gabor Szabo: To improve my chances. Actually, I think that should be the question. So what should I do to improve my chances that you actually find me, or employ me, and so on.

159 00:27:49.140 --> 00:28:00.230 Ran Reichman: Yeah, so it's a good. It's a great question. The easiest answer is, 1st of all to apply. that's that's the the 1st step, and we do look at applications. That that we get.

160 00:28:01.072 --> 00:28:04.150 Ran Reichman: I think. Given a certain application.

161 00:28:05.470 --> 00:28:09.219 Ran Reichman: You have to like our interview process.

162 00:28:09.682 --> 00:28:14.819 Ran Reichman: We. We work very hard for our interview process to be very similar to the work itself.

163 00:28:15.491 --> 00:28:36.339 Ran Reichman: I found that the at the like big tech, and most of the interviews are kind of IQ test. And it's not a bad thing like these companies like they they optimize for getting just very smart people, and obviously they're doing very well for with that. But for us, we want people who like during the interview really understand how their day to day is gonna look like.

164 00:28:36.440 --> 00:28:43.669 Ran Reichman: And they like it. They they see like they they do the interview task that we give them. And they say, Okay, this. These are the kinds of things that I want to do in the future.

165 00:28:43.840 --> 00:28:47.260 Ran Reichman: And sometimes people look at them and and they don't

166 00:28:47.370 --> 00:29:05.450 Ran Reichman: like they? They realize that they don't want to work on. I don't know low level optimization database. So what I would encourage like our website, Clarionio, you can see the kinds of technologies that we're using, which is like polars, data, fusion, arrow stuff like that.

167 00:29:05.580 --> 00:29:14.820 Ran Reichman: So if you engage with these projects and look at them and think how to use them. You don't even have to contribute to the open source. You can think like, Okay, how do? How do I use.

168 00:29:14.990 --> 00:29:16.870 Ran Reichman: and something like polars

169 00:29:18.430 --> 00:29:38.030 Ran Reichman: in data processing like, How how does that work? And if you're able to answer that question and share your experience and stuff like that. Then you're already ahead of, like, 90% of the people who who have no context don't know how any of these things work. And so oftentimes putting in the work puts you pretty much ahead.

170 00:29:39.170 --> 00:29:39.889 Gabor Szabo: Right?

171 00:29:40.980 --> 00:29:53.530 Gabor Szabo: okay. The next sort of the question of the expansion of this question would be, which is slightly, I feel strange with this question, because it sort of assumes a little bit of

172 00:29:53.891 --> 00:30:16.080 Gabor Szabo: moving ahead or or back in in time. So a little bit of time travel. But what would you suggest to someone if if the person has one or 2 years? So decides that, okay, I have no clue about rust and all of all of this stuff, but I know your company, and I really would like to work at at your company.

173 00:30:16.080 --> 00:30:26.009 Gabor Szabo: So I have. Now I'm going to start to do, learn things and do things. So in a year or 2 I have a much better chances to

174 00:30:26.710 --> 00:30:31.020 Gabor Szabo: get hired by Florian. Obviously you don't know what Florian will look like in 2 years.

175 00:30:31.020 --> 00:30:31.989 Gabor Szabo: Yeah, of course.

176 00:30:31.990 --> 00:30:41.889 Gabor Szabo: So that's why it's a little bit tricky question. On the other hand, you could think about it. What would you have suggested 2 years ago, or a year ago, for someone like this

177 00:30:42.040 --> 00:30:43.340 Gabor Szabo: to be hired now.

178 00:30:43.340 --> 00:30:50.260 Ran Reichman: Yeah, no, I I think that's a really interesting question to me. The answer is, if if you're looking at like the medium and long term.

179 00:30:50.520 --> 00:30:55.980 Ran Reichman: I think the my advice would just to be more ambitious. Like, if if you're saying like I

180 00:30:56.270 --> 00:31:08.050 Ran Reichman: for the next year or the next 2 years. I'm gonna work on this technology. Then you can really achieve a whole lot in that time, even as a side project. So I I would try to do something that excites me.

181 00:31:08.090 --> 00:31:28.381 Ran Reichman: Like 99% of the of the things that people work on. They just churn, they start working on it, and they they enjoy it for a while, and then they stop working for some reason. And that that's true for myself also, like that just happens like you start working on something, and then life happens, and you have a lot of other things to do. But if you're committed for a long time frame. Then you can really achieve a lot.

182 00:31:28.790 --> 00:31:36.020 Ran Reichman: and I would. I would just try to choose the something ambitious like, try to understand something, try to change something, try to do something like that.

183 00:31:41.010 --> 00:31:49.180 Gabor Szabo: Okay, yeah, I, I thought about some specific types of projects to work on or.

184 00:31:49.790 --> 00:32:01.669 Ran Reichman: So some people like, if we talk about specific projects like some people work on, for instance, the game engines and rust. If you're interested in gaming. There's this kind of joke that everybody wants to build a game engine in rust, but nobody wants to build a game.

185 00:32:01.900 --> 00:32:27.190 Ran Reichman: and so I don't think that's necessarily bad, but like these are the kinds of things like, if you're excited about gaming, try to build a game engine if you're excited about AI. Then try to see like what's relevant in AI with rust. I don't know if there's that much, but if you're excited about data, then you can look at these big data projects. There are quite a few at this point. Big rust projects online.

186 00:32:27.380 --> 00:32:50.029 Ran Reichman: And then I, I look at like the top 1520 rust projects on Github and say, like, what excites me here? What's interesting like, what would I want to build? What would I want to recreate. What would I want to benchmark or test, or stuff like that? And that also brings you connections like, if you, if you one of the things that I learned throughout my career is that when you reach out to successful people

187 00:32:50.614 --> 00:32:55.280 Ran Reichman: that are technical and you engage with what they're working on.

188 00:32:55.659 --> 00:33:03.900 Ran Reichman: Like, the response rate is huge. It's like, I don't know, maybe 90% or something like people people like that. People are excited about their technology and want to build on it.

189 00:33:04.420 --> 00:33:09.119 Ran Reichman: so finding those things that you actually want to engage with and actually engaging

190 00:33:09.685 --> 00:33:12.880 Ran Reichman: I I think is a is a great investment.

191 00:33:18.840 --> 00:33:21.160 Gabor Szabo: Yeah, that's that's an excellent point.

192 00:33:21.716 --> 00:33:24.769 Gabor Szabo: I I tried to Co, to

193 00:33:25.130 --> 00:33:29.710 Gabor Szabo: to recommend people all the time to to invest in open source

194 00:33:29.900 --> 00:33:43.889 Gabor Szabo: doing things in open source. But it's always a people get excited. But they they most of the people actually don't follow through this, and they do a little bit, and and then they abandon it the whole thing.

195 00:33:44.210 --> 00:33:50.790 Gabor Szabo: So those who do continue I guess they will stand out.

196 00:33:50.790 --> 00:34:02.239 Ran Reichman: Yeah, yeah, I think I think that's exactly right. I think because of the churn, and because most people don't go deep. So if you're able to go deep and and commit to something. Then again, you're you're ahead of, like 90% of people already.

197 00:34:07.240 --> 00:34:12.890 Gabor Szabo: So there's a comment here that for those a good start is trying to help in an existing open source project.

198 00:34:13.030 --> 00:34:14.480 Gabor Szabo: What do you think about that

199 00:34:16.440 --> 00:34:20.340 Gabor Szabo: open source, project or or create your new, create your own.

200 00:34:20.340 --> 00:34:36.189 Ran Reichman: I I wouldn't try to create my own as a start. But I think, even before helping even just using an open source project like. There's a huge one of the things that we're seeing at the flare on is that there's a huge variability

201 00:34:36.420 --> 00:34:39.879 Ran Reichman: in terms of what the open source project is able to do

202 00:34:40.510 --> 00:34:43.570 Ran Reichman: like some projects, especially in their core.

203 00:34:43.860 --> 00:34:55.739 Ran Reichman: They're super robust, they work, they, they, you just plug and play, and others are like they can be hard to use. They have a rough edges of various sorts. And being a user and understanding like.

204 00:34:56.170 --> 00:35:23.629 Ran Reichman: where does this technology really work. Well, where does it not work well, like? Why doesn't it work? Well? These are the kinds of things that you don't even have to start by like. Sometimes people are intimidated by contributing, because, like maybe people won't like what I contributed, or maybe I'll have a back and forth with some maintainer for days, and I won't get anything through. But just like starting with using and gaining insights and opening issues and saying, like, Hey, I saw this, is this. Okay, is this expected?

205 00:35:25.040 --> 00:35:36.049 Ran Reichman: again, these are the kinds of things that people just don't do. It sounds simple. It is simple, like it's not hard to take it to choose a project and and try to try to engage with it. But most people just don't do that.

206 00:35:37.400 --> 00:35:42.869 Gabor Szabo: Yeah. So a lot of a lot of this work is not very difficult, but time consuming.

207 00:35:43.170 --> 00:36:01.749 Ran Reichman: It's time consuming. It's an investment. There's no going around that. That's why it's valuable in a sense, like in the in the cryptocurrency world. There's a concept of a proof of work that you like show that you invested the time in something. I think, that's applicable to many, many aspects of life. So if you, if you invest that work, yeah, I think it has value.

208 00:36:03.060 --> 00:36:10.739 Gabor Szabo: Okay, so how do you evaluate the the decision that that you used? Rust?

209 00:36:11.040 --> 00:36:14.909 Gabor Szabo: What did you that you that you use your rust? Yeah. So.

210 00:36:15.610 --> 00:36:34.949 Ran Reichman: Yeah, it's a great question. It's a piercing question, I'd say, because it's it's hard to evaluate, right? You made such a big decision. And now you have to decide like, see if it's a good decision. I haven't regretted it yet, like I haven't seen a point where it's like, Oh, man, why did we do we use this technology? That was a huge mistake. We also have the very significant benefit of starting from scratch.

211 00:36:35.515 --> 00:36:42.215 Ran Reichman: So when you start from scratch. You don't have any legacy and before before the conversation we talked about

212 00:36:43.127 --> 00:37:00.820 Ran Reichman: like a migrating code to rust, so we don't really do that like we, we rewrite some things. And when you rewrite, then you're just like starting from scratch. So a lot of the pains of moving from one technology to another. We just skipped. It's much easier to start from scratch

213 00:37:01.857 --> 00:37:06.942 Ran Reichman: so I think I think it's too early to say for now like no regrets at this point.

214 00:37:08.110 --> 00:37:09.156 Ran Reichman: We'll see

215 00:37:10.100 --> 00:37:32.040 Gabor Szabo: Okay, what are the parts of of rust that or creates, or like the whole package? That you find exceptional good for for you or in general. And what? What are the areas where the rust world could improve? Where? It's something that hurts you.

216 00:37:33.280 --> 00:37:37.579 Ran Reichman: Yeah. So I'm I'll start with a positive I think

217 00:37:37.980 --> 00:37:54.099 Ran Reichman: rust in the past, say, 5 years has really matured in a in an impressive way. Like, you see, we engage with customers using all sorts of technologies, whether it's data, lake technologies or data processing or storage and stuff like that.

218 00:37:54.320 --> 00:37:55.320 Ran Reichman: And

219 00:37:56.448 --> 00:38:10.391 Ran Reichman: there's usually a crate for that, like the echoing the apples. There's an app for that. So usually there's a crate for that. Usually someone builds something pretty good that's able to use this technology, and and help

220 00:38:11.480 --> 00:38:13.060 Ran Reichman: help work with it.

221 00:38:15.330 --> 00:38:36.489 Ran Reichman: so that's something that I think is very good. I also think that the reliability is real like we. We did something that where we were integrating like Scala code and rust code. And suddenly there was like a memory corruption. And someone on our team was like, Oh, a memory corruption. I haven't seen one of those in years, so that that was like a moment of, Okay, yeah, this this rust thing is working.

222 00:38:36.650 --> 00:38:45.180 Ran Reichman: I'd say, the the 2 negatives that I can think of is one a build time

223 00:38:45.744 --> 00:39:05.519 Ran Reichman: there really is. It's a pain like building rust pretty quickly becomes pretty time consuming. And it's hard to optimize like when I when I worked in c plus plus, there were all sorts of tricks to to make the build run faster, even though I also encountered many situations where we had a very long build.

224 00:39:05.883 --> 00:39:23.279 Ran Reichman: But yeah, that that's that's a pain. And another one is, I'd say, the flip side of the there's a crate for that. But there's a lot of the support is that there's a lot of vaporware. I'd say there are like crates that you use them. And you're like, okay, this crate. It doesn't really work. And that's fine. I mean, you know, nobody like

225 00:39:23.620 --> 00:39:42.310 Ran Reichman: nobody's selling you that crate. It's just something that someone published online. But you realize that you have to. You have to prune it. You have to make decisions. You have to make sure that this this relates to your previous about, how do you choose the right crate? So you have to choose. You have to make sure that you're using something that you can believe in.

226 00:39:44.770 --> 00:40:12.500 Gabor Szabo: For a second, returning to the earlier conversation or a part of the conversation. We have another question here follow up to finding work as a web dev any suggestions for types of repos, types of projects that would be appreciated by employees employers if you contribute to. In your opinion, of course, I am contributing to programming languages. For example, I guess the

227 00:40:12.520 --> 00:40:17.530 Gabor Szabo: person means compilers. What do you mean? Programming languages.

228 00:40:23.480 --> 00:40:24.930 Ran Reichman: Yeah. So I think

229 00:40:25.750 --> 00:40:35.789 Ran Reichman: I think that's definitely good, like working on these kinds of technologies. It's not easy, something that like that that does differentiate you. But I will say

230 00:40:36.060 --> 00:40:43.710 Ran Reichman: that it's valuable to be able to like. I, currently, this is changing. But currently

231 00:40:44.217 --> 00:40:57.030 Ran Reichman: there's still a limited number of companies that are hiring for rust roles, and the the number is growing. But it's different. If you're coming to a company like aws, which does a lot of rust.

232 00:40:57.340 --> 00:41:25.589 Ran Reichman: or a company like Clarion that does a lot of us, just because, like, there are different use cases. So at Aws or Google, or something like that. You'll spend a lot of a lot more time on concurrency, because that's just like there's a lot of input, output happening inside their systems and a lot of micro services. So if I were interested in in a role in one of those companies, I'd probably try to understand like they have blog posts. They write interesting stuff about their challenges. I tried to understand a bit their stack

233 00:41:26.150 --> 00:41:27.080 Ran Reichman: and

234 00:41:27.591 --> 00:41:36.040 Ran Reichman: gain relevant experience. There, if we're talking about a company like Ferryon then, it's it's a different stack. So there are many islands in the rust world.

235 00:41:36.180 --> 00:41:38.988 Ran Reichman: and I I try to

236 00:41:39.890 --> 00:41:55.309 Ran Reichman: like, I think compilers are, are a great great place to start and if you find a a company building a compiler in rust, and obviously that's that's fantastic. But if you're looking at a company that's that's not doing exactly that. Then I would try getting acquainted with the with the tech stack that they're using.

237 00:41:56.210 --> 00:42:00.079 Gabor Szabo: Actually. For to this point I sort of

238 00:42:00.330 --> 00:42:17.380 Gabor Szabo: partially dreaming of about companies that would say to their to their candidates that, Okay, here are a couple of issues open in an open project, and your homework or home assignment for

239 00:42:17.380 --> 00:42:36.719 Gabor Szabo: for the interview process is to deal with those issues, and maybe not even directly related to the company. So to see how the person interacts with open source projects and and without and contributing to the world. Sort of

240 00:42:37.365 --> 00:42:37.660 Gabor Szabo: yeah.

241 00:42:37.660 --> 00:42:58.200 Ran Reichman: Yeah, I totally agree. I'd also add that the big advantage of engaging with projects that are related to the company is that you get a better understanding if you want to work there. This touches on what I mentioned earlier, like sometimes you, you might think that you want to work with. But then you look at like the the stack, what they're building, and you say, that that's not really my thing.

242 00:42:58.270 --> 00:43:09.230 Ran Reichman: And the the best time I. This is what I tell the candidates as well. The best time to understand that is, there is like, before you join the company. And cause. Yeah, it's really important to write that to find the right fit.

243 00:43:09.810 --> 00:43:28.770 Gabor Szabo: So here we have a very technical question or more technical than what we had. So far, high performance data data processing is is what you are. That's, I think the statement fly around inside. I don't know where this sentence comes from, so could you share any valuable practical examples

244 00:43:28.770 --> 00:43:44.370 Gabor Szabo: or tricks, how you debug distributed and high performance use cases. Do you use Tokyo for development, or just something like wrappers around arrow data, fusion, and so on. Any other valuable recommendations.

245 00:43:46.010 --> 00:43:47.834 Ran Reichman: Yeah, it's a big question.

246 00:43:49.980 --> 00:43:56.000 Ran Reichman: 1st of all, I mentioned this. But I'll mention it again, because it's just so important, like tests

247 00:43:56.250 --> 00:44:00.129 Ran Reichman: across the stack matter a whole lot. And

248 00:44:00.850 --> 00:44:07.189 Ran Reichman: this varies across companies. Because if you're building a like, I've I have some experience like with like a front end development.

249 00:44:07.370 --> 00:44:27.850 Ran Reichman: and there I don't know if I didn't invest a huge amount of my time in tests. You mostly want to iterate and see that it works and find bugs and solve them. When you're building a mission critical software, which is what we're doing. You really want things to be exact, like some startups can move fast and break things at play around. We don't move. We try to move as fast as possible, but

250 00:44:28.350 --> 00:44:51.179 Ran Reichman: it really needs to be stable. So this means integration tests, system tests, unit tests. These are the kinds of things that that are very useful to debug even distributed and high performance systems, because even a distributed system eventually includes various components and interactions between those components. And if you test those well.

251 00:44:51.380 --> 00:44:54.490 Ran Reichman: then you reduce the number of cases that said

252 00:44:54.620 --> 00:45:01.289 Ran Reichman: our team finds itself running something for 3 h on 2 TB of data in order to find all sorts of edge cases.

253 00:45:01.630 --> 00:45:02.950 Ran Reichman: And there.

254 00:45:03.110 --> 00:45:04.190 Ran Reichman: I think.

255 00:45:05.150 --> 00:45:12.210 Ran Reichman: 1st of all, it's not something that we've solved, I'd say, and we're working hard on building tooling.

256 00:45:12.650 --> 00:45:37.429 Ran Reichman: That extracts data from the data processing pipeline and visualizes it in a way that's easy to understand. So that you understand, like, how much memory you're using, how much CPU like, why is it happening? How much disk? And interestingly, this is something that is also gonna be valuable for our customers. So like, we make data processing much more efficient, much faster, much more performant.

257 00:45:38.376 --> 00:45:49.580 Ran Reichman: But by doing that we also wanna visualize this to our customers. So in a sense, we wanna visualize it to ourselves to understand what the bottlenecks are, and then visualize it to our customers. This is a hard thing to do.

258 00:45:51.640 --> 00:46:01.180 Ran Reichman: so I I would say, we we've solved it. But I'd say, adding a lot of debugging. We use also a a Tracy

259 00:46:01.360 --> 00:46:03.801 Ran Reichman: actually, as a tool to

260 00:46:04.570 --> 00:46:11.639 Ran Reichman: defined performance issues, and it's quite effective so when you're able to attach things to your code.

261 00:46:11.800 --> 00:46:14.280 Ran Reichman: and they do all sorts of

262 00:46:16.100 --> 00:46:24.969 Ran Reichman: performance, monitoring of various sorts and benchmarking we found that to be valuable, especially when when debugging performance issues.

263 00:46:27.390 --> 00:46:47.120 Gabor Szabo: So the next question that coming from the audience is actually the next question I wanted to ask. So I'm going to ask in the way I thought about sort of is that to try to understand what is your experience? Using AI tools to write rust code, which

264 00:46:47.770 --> 00:46:51.410 Gabor Szabo: tool you might be using, which model.

265 00:46:52.960 --> 00:46:59.420 Ran Reichman: Yeah. So 1st of all, let's say, we're model agnostic at Flareon I found that the AI

266 00:46:59.910 --> 00:47:19.169 Ran Reichman: it's similar to ides and even operating systems. People have their preferences. And as a as a manager, I I'm not gonna push someone to use a certain flavor of AI, because because I have a preference for it. Like, I trust the the team members to

267 00:47:19.650 --> 00:47:26.699 Ran Reichman: try to be as effective and efficient as possible. And we bring people that like are trustworthy in that regard.

268 00:47:27.287 --> 00:47:42.000 Ran Reichman: I've had good experience with Cloud. I think it's it's good for software development. Some team members really like a chat gpt some like deep seek they found, especially our one to be effective.

269 00:47:43.830 --> 00:47:45.410 Ran Reichman: I'll say that the things that

270 00:47:45.540 --> 00:47:50.200 Ran Reichman: the AI is best at in terms of our development is,

271 00:47:52.070 --> 00:48:06.599 Ran Reichman: 1st of all, needle in a haystack issues where you have like this huge error. And you say, like, Hey, AI! Like, what? What do you think is going on here? And then it's like, Oh, you! You wrote this incorrectly, and you should fix it. And usually, usually that's just right. Like you take a blob of code. You take the error

272 00:48:07.190 --> 00:48:11.500 Ran Reichman: 9 out of 10 times. It says like this is probably there. And and it's right.

273 00:48:13.520 --> 00:48:42.860 Ran Reichman: basic functionality. Is good. But usually that doesn't save that much money. I think the metric Sam Altman has said, I said this, and I 100% agree. I think the metric of like percent of code written by AI is is what in startup world they call a vanity metric which is like it's. It sounds interesting, but it doesn't really tell you how much how much you're using. Because, like autocomplete, like, how much of my text that I write in emails is written by autocomplete? Probably a lot. But like, how significant is that to my

274 00:48:43.170 --> 00:48:45.649 Ran Reichman: in my process, and not too much.

275 00:48:48.040 --> 00:48:53.059 Ran Reichman: I will say that where AI isn't as good is when things get complex.

276 00:48:53.310 --> 00:48:55.449 Ran Reichman: and that happens a lot for us.

277 00:48:55.880 --> 00:49:02.270 Ran Reichman: If you're trying to write something very performant. If you're trying to write something that's distributed and

278 00:49:02.390 --> 00:49:27.841 Ran Reichman: different things impact each other, whether it's memory. CPU disk, usage networking. Once many parameters get into the equation. Usually the AI focuses on some local minimum and not on like the whole system, and we found it to be very difficult to get it to solve. Those kinds of problems which is kind of fun. Because, like you want to be working on things that are

279 00:49:29.031 --> 00:49:34.358 Ran Reichman: not like the AI has trouble with, because otherwise, I mean, I don't know. You can just get the AI to do them. So

280 00:49:37.560 --> 00:50:06.820 Gabor Szabo: Let's switch a little bit to a slightly different audience. The audience, that part of the people who are here. I guess they're part of that group. If you're talking to other startup founders, or Ctos or so manager level people, or or co-founders, what would you recommend them? How to decide whether to use rust

281 00:50:06.870 --> 00:50:08.860 Gabor Szabo: or or not to use rust.

282 00:50:11.550 --> 00:50:12.220 Ran Reichman: Yeah, so.

283 00:50:12.220 --> 00:50:15.819 Gabor Szabo: How to, how should they evaluate it, or.

284 00:50:17.270 --> 00:50:25.230 Ran Reichman: So the place I'd start is, you want to have some familiarity with it. You like you want to champion. I think that's true with any new technology.

285 00:50:26.069 --> 00:50:29.501 Ran Reichman: You don't wanna like if you have.

286 00:50:31.026 --> 00:50:40.180 Ran Reichman: an engineer with the 3 years of experience, and they say, like, hey? Rust is exciting. I want to bring this to the company. You're unlikely to be successful by doing that.

287 00:50:40.560 --> 00:50:42.820 Ran Reichman: but if you have someone who can.

288 00:50:43.080 --> 00:50:50.090 Ran Reichman: who can experiment. Who can mentor who can make decisions on the right projects for this technology?

289 00:50:50.879 --> 00:51:01.740 Ran Reichman: Then I think you're much more likely to be successful. And I mentioned this earlier, but I'll mention it again, because I really think it's it's crucial, is choosing the right projects

290 00:51:02.040 --> 00:51:09.050 Ran Reichman: is super super important. So if you have like a contained project that you know what you want to achieve there, and you're starting from scratch.

291 00:51:09.230 --> 00:51:17.280 Ran Reichman: and you want to do that with rust, and you have the the know how, then I don't see why it shouldn't succeed like it's a very much set up for success.

292 00:51:17.400 --> 00:51:20.084 Ran Reichman: But the more the more the project is

293 00:51:20.720 --> 00:51:28.519 Ran Reichman: distanced from that situation, I think the less likely it is that that, it'll it'll be a success.

294 00:51:32.260 --> 00:51:33.280 Gabor Szabo: Okay.

295 00:51:34.410 --> 00:51:44.839 Gabor Szabo: I am, I think, mostly at the end of of my questions. I don't know if the audience have more questions. The audience who is here, or if you have the

296 00:51:45.320 --> 00:52:02.240 Gabor Szabo: subjects that you would like to bring up, that I I didn't ask because I didn't think about that important, and you think it would be important to for people to know about the company, about the use of rust, how to apply for a job at you to your company.

297 00:52:03.370 --> 00:52:06.200 Ran Reichman: Yeah. So how how to apply?

298 00:52:06.320 --> 00:52:19.700 Ran Reichman: It's pretty easy, like we have linkedin posts at our company, so you can look at Linkedin, at at flare on and see probably the most relevant here at the low level developer, which is how we call our rust position.

299 00:52:21.420 --> 00:52:27.170 Ran Reichman: Yeah, I think there's a lot of exciting momentum in the rust world. Lots of talent.

300 00:52:27.370 --> 00:52:30.350 Ran Reichman: I think the fact that big tech is investing in rust

301 00:52:30.570 --> 00:52:36.710 Ran Reichman: is really significant. Because, it just creates

302 00:52:37.390 --> 00:52:48.250 Ran Reichman: a whole set of people who are being trained and using the rust in production, and they also contributing to open source projects. So I think that's great.

303 00:52:48.870 --> 00:52:55.240 Ran Reichman: And yeah, lots of exciting stuff. Here, we're we're in terms of Larry on. So we're

304 00:52:56.010 --> 00:53:14.129 Ran Reichman: like, the world of data is so vast. And there's a there's so much to do here, and so many engines and technologies that can be applied when a company wants to do data processing very efficiently. So we're obviously excited about that future. And we think about rost has a has an important role. There.

305 00:53:16.500 --> 00:53:20.470 Gabor Szabo: Actually, I just thought about a new question, what are the main

306 00:53:20.890 --> 00:53:33.290 Gabor Szabo: problems that Florian is is facing that your engineers will need to solve in the foreseeable future that the new people who are joining the team might need to work on.

307 00:53:34.600 --> 00:53:43.313 Ran Reichman: Yeah. So I mean, I'd say, our engineers are pretty fortunate to have pretty tough challenges. so

308 00:53:44.160 --> 00:53:51.380 Ran Reichman: in in many senses. We're building a a distributed database for data processing, and that means

309 00:53:51.710 --> 00:53:55.649 Ran Reichman: handling issues of a very significant scale

310 00:53:55.900 --> 00:54:12.259 Ran Reichman: of a disk usage of memory management. these are the kinds of things that we're we're excited about like, how much, how much CPU is this using? How much memory is this? Designed correctly. Should we redesign this part of code of the code, should we?

311 00:54:14.072 --> 00:54:19.147 Ran Reichman: sometimes we, we insert many fast paths into our code, so that,

312 00:54:20.238 --> 00:54:25.790 Ran Reichman: when a customer is using is using it naively, and we can get a big performance boost

313 00:54:26.350 --> 00:54:39.550 Ran Reichman: so lots of challenges in that area, it's like CPU memory large scale of data and and performance. Those are the kinds of things that we encounter basically every day.

314 00:54:39.790 --> 00:54:49.780 Ran Reichman: And we also encounter a lot of like new and interesting technologies because our customers have a lot of new and interesting technologies that we we have to learn about them support them, etcetera.

315 00:54:50.850 --> 00:54:55.979 Gabor Szabo: Actually, who? Who are your customers, or what type of of companies are? Are your customers, or

316 00:54:56.750 --> 00:54:58.330 Gabor Szabo: could be your customers.

317 00:54:58.900 --> 00:55:04.656 Ran Reichman: Yeah. So our our customers are mostly the enterprise. meaning the companies that

318 00:55:05.478 --> 00:55:13.230 Ran Reichman: that are very significant data infrastructure. Because they're the ones that carry them care the most about performance. So if the company has a

319 00:55:13.360 --> 00:55:19.639 Ran Reichman: hundreds or thousands of data processing jobs, whether it's a spark array, or hadoop, or trino.

320 00:55:19.830 --> 00:55:27.419 Ran Reichman: These are the kinds of companies that really care about performance that really have pains in terms of managing their spark and their data infrastructure in general.

321 00:55:27.590 --> 00:55:32.639 Ran Reichman: And they're they're the ones that that are most excited about what Flarion brings to the table.

322 00:55:34.620 --> 00:55:41.769 Gabor Szabo: Okay, probably that should. That shouldn't have been the the last question. But so if somehow, this is how it turned out, anyway.

323 00:55:41.770 --> 00:55:42.170 Ran Reichman: Okay.

324 00:55:42.420 --> 00:55:50.540 Gabor Szabo: I don't see any more questions from the audience any any final words for this meeting podcast.

325 00:55:51.180 --> 00:55:58.989 Ran Reichman: No, I mean, I I appreciate this conversation and thanks everyone for joining and asking interesting questions. And yeah, thank you, Gabor, for organizing.

326 00:55:59.380 --> 00:56:22.929 Gabor Szabo: Thank you very much, and I really enjoyed it. And if you're watching this as a video, then please like the video. And if you listen to on, on the podcast, then in the show notes, there are going to be links where you can find the company and the other things that we discussed. And thank you, everyone for. Thank you, Ron, to

327 00:56:22.930 --> 00:56:30.949 Gabor Szabo: be here, and everyone else who joined us and asked questions that were enhanced. I think the the whole conversation.

328 00:56:31.000 --> 00:56:33.560 Gabor Szabo: and thank you everyone for listening.

329 00:56:33.960 --> 00:56:34.890 Gabor Szabo: Goodbye.

330 00:56:35.260 --> 00:56:35.960 Ran Reichman: Thank you.

Example: Simplified Spaghetti Bolognese

• Simplified Spaghetti Bolognese depends on Cooked pasta and Sauce
• Cooked pasta depends on Dry Pasta and Boilding Water
• Sauce depends on Pealed Onion, Pepper, Pealed Tomato

Based on this one could establish an order in which things need to be prepared and one could also establish the list of things that can be done in parallel.

Example: Omlet

Sometimes, however you find yourself in trouble. For example:

• Omlet depends on Egg
• Egg depends on Chicken
• Chicken depends on Egg

Here we don't know if we'll need the Egg or the Chick firts. We have a circular dependency.

Examples in code

examples/try-toplogical-sort/src/main.rs

use topological_sort::TopologicalSort;

fn main() {
    independent_things();
    pop_independent_things();
    simple_dependencies();
    complex_dependencies();
    circular_dependencies();
    pop_circular_dependencies();

    many_circular_dependencies();
}

// First < Second < Third
fn simple_dependencies() {
    let mut ts = TopologicalSort::<&str>::new();
    ts.add_dependency("First", "Second");
    ts.add_dependency("Second", "Third");
    assert_eq!(ts.len(), 3);

    // Fetch the elements that don't depend on anything
    let all = ts.pop_all();
    assert_eq!(all.len(), 1);
    assert_eq!(all[0], "First");

    let all = ts.pop_all();
    assert_eq!(all.len(), 1);
    assert_eq!(all[0], "Second");

    let all = ts.pop_all();
    assert_eq!(all.len(), 1);
    assert_eq!(all[0], "Third");

    let all = ts.pop_all();
    assert_eq!(all.len(), 0);
}

fn independent_things() {
    let mut ts = TopologicalSort::<&str>::new();
    assert_eq!(ts.len(), 0);
    assert!(ts.is_empty());

    ts.insert("A");
    ts.insert("B");
    ts.insert("C");
    assert_eq!(ts.len(), 3);
    // println!("{:?}", ts);


    // The order of insertion does not matter, we get the items in arbitrary order
    let all = ts.pop_all();
    assert_eq!(all.len(), 3);
    for thing in ["A", "B", "C"] {
        assert!(all.contains(&thing));
    }

    assert!(ts.is_empty());
}

fn pop_independent_things() {
    let mut ts = TopologicalSort::<&str>::new();
    assert_eq!(ts.len(), 0);
    assert!(ts.is_empty());

    ts.insert("A");
    ts.insert("B");
    ts.insert("C");
    assert_eq!(ts.len(), 3);

    // The order of insertion does not matter, we get the items in arbitrary order
    let mut all = vec!["A", "B", "C"];

    for _ in 0..3 {
        let elem = ts.pop();
        let elem = elem.unwrap();
        assert!(all.contains(&elem));
        let index = all.iter().position(|x| *x == elem).unwrap();
        all.remove(index);
    }
    assert_eq!(all.len(), 0);
    assert_eq!(ts.len(), 0);
}

// First A < Second
// First B < Second
// Second < Third A
// Second < Third B
fn complex_dependencies() {
    let mut ts = TopologicalSort::<&str>::new();
    ts.add_dependency("First A", "Second");
    ts.add_dependency("First B", "Second");
    ts.add_dependency("Second", "Third A");
    ts.add_dependency("Second", "Third B");
    assert_eq!(ts.len(), 5);

    let all = ts.pop_all();
    assert_eq!(all.len(), 2);
    assert!(all.contains(&"First A"));
    assert!(all.contains(&"First B"));

    let all = ts.pop_all();
    assert_eq!(all.len(), 1);
    assert!(all.contains(&"Second"));

    let all = ts.pop_all();
    assert_eq!(all.len(), 2);
    assert!(all.contains(&"Third A"));
    assert!(all.contains(&"Third B"));
}

// Chicken <-> Egg
fn circular_dependencies() {
    let mut ts = TopologicalSort::<&str>::new();
    ts.add_dependency("Chicken", "Egg");
    ts.add_dependency("Egg", "Chicken");
    // println!("{:?}", ts);

    // if pop_all returned an empty vector and there are still elements in the TS
    // that means the dependencies are circular
    let all = ts.pop_all();
    assert_eq!(all.len(), 0);
    assert_eq!(ts.len(), 2);
}

// Chicken <-> Egg
// Shakshuka < Egg
// Chicken < Qqrq
fn pop_circular_dependencies() {
    let mut ts = TopologicalSort::<&str>::new();
    ts.add_dependency("Chicken", "Egg");
    ts.add_dependency("Egg", "Chicken");
    ts.add_dependency("Shakshuka", "Egg");
    ts.add_dependency("Chicken", "Qqrq");
    // println!("{:?}", ts);

    let elem = ts.pop();
    assert_eq!(elem, Some("Shakshuka"));

    let elem = ts.pop();
    assert_eq!(elem, None);
}


fn many_circular_dependencies() {
    let mut ts = TopologicalSort::<&str>::new();
    ts.add_dependency("Chicken", "Egg");
    ts.add_dependency("Egg", "Chicken");

    ts.add_dependency("Egg", "Omlet");
    // ts.add_dependency("A", "Egg");
    // ts.add_dependency("B", "Omlet");
    // ts.add_dependency("A", "B");
    // ts.add_dependency("B", "A");


    println!("{:?}", ts);
    assert_eq!(ts.pop(), None);
}

examples/try-toplogical-sort/Cargo.toml

[package]
name = "try-toplogical-sort"
version = "0.1.0"
edition = "2024"

[dependencies]
topological-sort = "0.2.2"

In this online session Leon Vak, who gave 3 excellent presentations about Embedded programming and Linux kernel programming with Rust at Abra, is going to show us how he uses Rust to write programs for an embedded device.

• Debian Benchmark
• Source code

Transcript

1 00:00:01.900 --> 00:00:21.539 Gabor Szabo: So Hello, and and welcome to the Code Maven and Meetup Group. And if you're watching the video, then the Code Maven Youtube, Channel and my name is Gabor Sobo. I usually teach rust and python, and how companies introduce these languages or introduce testing for these languages, and I also organize the

2 00:00:21.950 --> 00:00:50.339 Gabor Szabo: Both the rust and the python meetup groups here in Israel. And I also have this Code Mavens Group, where I try to organize presentations both in rust and in python, in English, in zoom. So we can reach all the international community. And we can also invite people. If you look at the history. You can find all kind of other videos from other people about all kind of interesting subjects in these 2 languages.

3 00:00:50.812 --> 00:00:59.000 Gabor Szabo: Is that said, I am really happy, Leon, that you agreed to give this presentation. I think this is the 3rd time you're already giving this or so so

4 00:00:59.000 --> 00:00:59.780 Leon: Yeah.

5 00:01:00.216 --> 00:01:26.380 Gabor Szabo: And but this time it's in English. So we'll have it also for the international community and recorded. And thank you very much everyone who joined us. As I said earlier, you can feel free to ask questions in the chat, and if you don't want to speak up, and that's it, I think. Now the stage is yours.

6 00:01:26.980 --> 00:01:27.570 Leon: Alright!

7 00:01:27.670 --> 00:01:31.940 Gabor Szabo: Share your screen. You can talk without sharing your screen whatever you like.

8 00:01:32.420 --> 00:01:46.970 Leon: All right, all right, all right, we're there the right. So let me just share the screen again.

9 00:01:49.430 --> 00:01:52.930 Leon: Alright. So you guys will be

10 00:01:53.900 --> 00:01:56.700 Leon: able to see my screen very soon

11 00:01:56.700 --> 00:01:58.690 Gabor Szabo: Yeah, we see the embedded summer camp

12 00:01:59.020 --> 00:02:06.749 Leon: Okay, okay, okay, okay, very good. So right? So this this meetup was a

13 00:02:07.140 --> 00:02:10.999 Leon: was created as a part of 3.

14 00:02:11.860 --> 00:02:18.329 Leon: 3 separate meetups we have arranged in our company called Abra.

15 00:02:18.470 --> 00:02:28.430 Leon: and this was the the specific one we're talking about right now is the rust in embedded systems, and

16 00:02:29.150 --> 00:02:31.490 Leon: and it was a

17 00:02:31.970 --> 00:02:47.240 Leon: it was the second one. The 1st one was Linux Kernel Development, which was not related to rust at all. The second one was the rust in embedded systems, and the last one was rust in Linux Kernel.

18 00:02:49.070 --> 00:02:59.470 Leon: This series was quite interesting for me to prepare and to present, and I hope you'll find it.

19 00:03:00.025 --> 00:03:02.050 Leon: at least a bit amusing.

20 00:03:02.460 --> 00:03:03.780 Leon: M.

21 00:03:04.210 --> 00:03:07.209 Leon: So, right, we?

22 00:03:09.926 --> 00:03:13.219 Leon: yeah. 1st of all, I my name is Leon.

23 00:03:13.410 --> 00:03:14.240 Leon: Right?

24 00:03:14.350 --> 00:03:19.780 Leon: That's enough. And you know, we, the rest people.

25 00:03:20.060 --> 00:03:24.990 Leon: We we have. We clearly have some issues right?

26 00:03:25.662 --> 00:03:32.320 Leon: And you will. I guess by now you already are aware about

27 00:03:32.580 --> 00:03:41.690 Leon: our little problems. But you know that's why we're here today. So I hope you'll and Joyce

28 00:03:42.611 --> 00:04:03.329 Leon: we will be talking about rust for embedded and we will mention how rust for embedded systems for bare metal, embedded systems is not the same as rust for you know, when you develop in user space like Linux windows, whatever

29 00:04:04.181 --> 00:04:10.899 Leon: we will mention the fact that rust provides your

30 00:04:11.640 --> 00:04:21.590 Leon: gives you or lets you develop in a full. It's very supporting ecosystem for embedded and specifically for bare metal.

31 00:04:22.340 --> 00:04:31.600 Leon: And we will be questioning just a little bit rust versus C and C plus plus in the embedded. Just to touch on that, because

32 00:04:32.060 --> 00:04:33.629 Leon: it's hard not to.

33 00:04:33.940 --> 00:04:41.539 Leon: And what we will not be doing today, we will not be learning what embedded development is. I

34 00:04:41.750 --> 00:04:45.869 Leon: hope that you guys have any well, just

35 00:04:46.020 --> 00:05:03.269 Leon: any sort of idea about it up to now. And we will not be mentioning concepts like serial port and the leads, the leds switching on and off, and so on. Right? I assume that you

36 00:05:03.410 --> 00:05:09.889 Leon: are aware about these things, and we are not going to be learning the rust language.

37 00:05:10.300 --> 00:05:14.369 Leon: It's not about learning rust language. I hope you will

38 00:05:14.620 --> 00:05:18.459 Leon: see what the presentation is about.

39 00:05:18.977 --> 00:05:31.299 Leon: There are not many slides here. We'll just speak very quickly about a few slides here like 3, 4 slides, and then we will switch to a hands on a demo

40 00:05:32.256 --> 00:05:45.963 Leon: which is which has a little issue today. Because, there is one thing that's not working for some reason, but we will get over it. And right. So let's

41 00:05:46.770 --> 00:05:47.819 Leon: go ahead.

42 00:05:49.640 --> 00:05:52.310 Leon: What are we?

43 00:05:52.600 --> 00:05:56.299 Leon: Well, I I cannot say we're all familiar with that, but

44 00:05:57.121 --> 00:06:23.460 Leon: many of us are well familiar with it, with the good old dead old days when you were quite locked, with a development under a specific platform and a specific ide, and the specific debugger. And whatever zylogue is a good example, I used to work with it once. And yeah, so we had an ide just for it.

45 00:06:23.800 --> 00:06:30.909 Leon: Special debugger probe, and everything is quite unique for this platform.

46 00:06:31.950 --> 00:06:48.280 Leon: And so yeah, so it's all about the Ics, the chips eventually. So the chip was from Zylogue, and the Id was developed by them, and the compiler and the debugger. Everything is just.

47 00:06:48.690 --> 00:06:50.650 Leon: you know, very custom.

48 00:06:52.730 --> 00:07:02.630 Leon: And now we have rust, and this is very, very different from C, because

49 00:07:03.420 --> 00:07:18.349 Leon: well, we have the next slide. So why rush 1st of all, we will be moving from vendor login to freedom. We are really capable of developing whatever we want without any.

50 00:07:18.650 --> 00:07:26.759 Leon: I am any code supplied by the vendor entirely.

51 00:07:27.510 --> 00:07:34.549 Leon: and we will use any id that we like I used. I'm used to work with

52 00:07:35.420 --> 00:07:40.020 Leon: this code, but you can use any id

53 00:07:40.290 --> 00:07:50.280 Leon: of choice. You don't need an idea. You can use just the code editor. And for the hardcore guys you can do everything in them.

54 00:07:50.980 --> 00:07:52.250 Leon: M.

55 00:07:52.770 --> 00:07:58.590 Leon: And what's good about rust compared to the bare metal C programming.

56 00:07:58.840 --> 00:08:09.209 Leon: It's the power of modern language in embedded programming. It's just incredible what stuff you can do in bare metal. If you

57 00:08:09.820 --> 00:08:18.950 Leon: you know, if you if you're used to bare metal programming in C, then the switch to rust would just knock your mind off.

58 00:08:19.580 --> 00:08:27.890 Leon: M, yeah. And why? Rust, of course, unmatched safety concurrency. And what about the performance?

59 00:08:29.070 --> 00:08:36.760 Leon: Well, we really need to talk about it. Because that's 1 of the main questions people always ask about.

60 00:08:36.860 --> 00:08:43.650 Leon: You know why use rust and not c not c plus plus in embedded development.

61 00:08:43.990 --> 00:08:51.310 Leon: So and many times everything boils down to performance.

62 00:08:52.700 --> 00:09:00.640 Leon: I will give you the tools to measure your own and performance requirements.

63 00:09:00.810 --> 00:09:04.850 Leon: So let's Luke over here.

64 00:09:05.620 --> 00:09:10.329 Leon: You have the I'll try to make it slightly bigger

65 00:09:10.985 --> 00:09:16.219 Leon: you have the benchmark game. Right? This is under Debian.

66 00:09:16.990 --> 00:09:22.079 Leon: Okay, debian.net benchmark game. You can find it easily on the net.

67 00:09:22.440 --> 00:09:23.900 Leon: Okay, no worries.

68 00:09:24.050 --> 00:09:31.630 Leon: And and you have certain comparisons of rust versus

69 00:09:32.470 --> 00:09:36.419 Leon: other languages. So let's take C, for example.

70 00:09:37.040 --> 00:09:41.829 Leon: right? And you have the comparison to Gcc.

71 00:09:42.210 --> 00:09:47.400 Leon: and you have different algorithms here. Everything is very, very, you know.

72 00:09:47.620 --> 00:09:57.069 Leon: Open. So if you click on the specific algorithm, you get the all kind of measurements.

73 00:09:57.690 --> 00:10:03.419 Leon: And you can get to the algorithm itself, the implementations, everything is here. It's all.

74 00:10:03.790 --> 00:10:06.780 Leon: It's all open source and available.

75 00:10:08.360 --> 00:10:16.690 Leon: So when you compare rust to C with Gcc. For example, you can see the you know

76 00:10:17.360 --> 00:10:19.880 Leon: the different runs here.

77 00:10:20.400 --> 00:10:48.149 Leon: and you can sort it. You can do a lot of things here, but eventually you will see that rust is not better than C. And C is not better than rust depending on an algorithm and on the tests performed in some, in some C would be quicker in some rust will take the 1st places.

78 00:10:48.350 --> 00:10:49.969 Leon: It's just, you know.

79 00:10:50.210 --> 00:10:53.650 Leon: It's all right. They are quite the same eventually.

80 00:10:53.880 --> 00:11:00.679 Leon: so no need to worry about performance. The performance is, how do you define it?

81 00:11:00.870 --> 00:11:04.079 Leon: I suppose it's as good as it gets.

82 00:11:04.890 --> 00:11:13.699 Leon: at least, you know, using modern compilers and systems, you can instead compare it to the C. Lang.

83 00:11:13.840 --> 00:11:18.220 Leon: And once again, the picture doesn't change much.

84 00:11:19.720 --> 00:11:28.969 Leon: so feel free to go to this site and and check it for yourself. I will not be teaching you what's

85 00:11:29.140 --> 00:11:30.960 Leon: the best for you.

86 00:11:31.390 --> 00:11:36.540 Leon: You can compare it to any language, and with different algos and whatever.

87 00:11:37.260 --> 00:11:48.149 Leon: So enough with that, I suppose. It's quite clear right now, why does it start again?

88 00:11:48.560 --> 00:11:54.029 Leon: Okay, sorry. Okay, so this is about the performance.

89 00:11:54.780 --> 00:11:59.740 Leon: you know, talking about safety, concurrency, and whatever you.

90 00:12:00.560 --> 00:12:02.379 Leon: I guess that by now you're

91 00:12:02.730 --> 00:12:12.649 Leon: trust shines on these sides and way way better than C. So if the performance is the same, so why choose any other language?

92 00:12:14.003 --> 00:12:17.730 Leon: Oh, yeah. By the way, this is Ferris.

93 00:12:19.090 --> 00:12:23.570 Leon: Just so you know this is the mascot. His name is Ferris.

94 00:12:24.299 --> 00:12:37.200 Leon: Any idea why, he's called Ferris? It's very simple, Ferro, like rust, like whatever programmers jokes.

95 00:12:38.160 --> 00:12:47.950 Leon: M, all right. So what and how the bare metal programming is different.

96 00:12:50.400 --> 00:12:55.889 Leon: Well, eventually, when you write any program for

97 00:12:56.540 --> 00:13:03.409 Leon: see for for for any OS like Windows or Linux, or whatever.

98 00:13:03.860 --> 00:13:14.139 Leon: Eventually your code will swap to using C interfaces because the operating systems.

99 00:13:14.320 --> 00:13:23.300 Leon: not all of them, but most of them are written with C, and your code will just

100 00:13:25.230 --> 00:13:29.020 Leon: run C code eventually under the hood.

101 00:13:29.890 --> 00:13:33.620 Leon: Here is an example using the foreign function interface.

102 00:13:34.460 --> 00:13:40.610 Leon: This is this comes from the rust. It's just an random example

103 00:13:40.730 --> 00:13:51.059 Leon: and rust lang rust. 3 master library, Std. Src. OS unix Fs. So this is a file system library

104 00:13:51.360 --> 00:13:52.810 Leon: for unix.

105 00:13:53.030 --> 00:13:57.880 Leon: And this is just one function from it. Make dear function.

106 00:13:58.300 --> 00:13:59.600 Leon: What does it do?

107 00:14:01.040 --> 00:14:06.579 Leon: It simply calls the lip. See? Make deer on this machine.

108 00:14:07.380 --> 00:14:18.040 Leon: This is quite clear. And because these things, these things are implemented on the Lipsy level, and

109 00:14:18.400 --> 00:14:20.120 Leon: everything boils down to that.

110 00:14:21.810 --> 00:14:25.730 Leon: There is certain questions that one may ask.

111 00:14:25.900 --> 00:14:29.319 Leon: If it all boils, boils down to C, then why use rust?

112 00:14:29.910 --> 00:14:31.759 Leon: Well if you can.

113 00:14:32.030 --> 00:14:34.520 Leon: Right? If you can write

114 00:14:34.620 --> 00:14:44.480 Leon: big apps with lots of business logic and feel safe on memory issues and everything else rust helps you with.

115 00:14:44.930 --> 00:14:49.319 Leon: Then I think you've done a good job here.

116 00:14:50.070 --> 00:14:58.979 Leon: anyway. A foreign function. Interface is an interesting topic to read about Ffi. You can find it easily on the network.

117 00:14:59.450 --> 00:15:03.720 Leon: And, by the way, rust is an open source language.

118 00:15:04.651 --> 00:15:07.539 Leon: Just try to find

119 00:15:07.720 --> 00:15:14.089 Leon: the code for make deer in lip C. It will take you some time, I promise you that

120 00:15:14.190 --> 00:15:20.950 Leon: it's not that easy with rust. You just get there almost immediately with any search on the network.

121 00:15:23.330 --> 00:15:28.359 Leon: So yeah, so you are programming in rust. However.

122 00:15:28.710 --> 00:15:34.490 Leon: you're getting to see interfaces on the OS abis.

123 00:15:36.270 --> 00:15:41.220 Leon: The rest for embedded is very different on these regards. Well.

124 00:15:41.350 --> 00:15:47.960 Leon: once again, when I say rust for embedded here, I mean rust for bare metal embedded systems. All right.

125 00:15:48.310 --> 00:15:54.669 Leon: So as you can see at first, st you see. Well, you guys, I don't know. Some of you may

126 00:15:54.830 --> 00:16:01.030 Leon: have experience with Russ. Some not. I will explain. Some basics. Don't worry about it. So

127 00:16:02.130 --> 00:16:05.690 Leon: you have the no Std. And no main.

128 00:16:06.030 --> 00:16:07.530 Leon: Why is that?

129 00:16:07.870 --> 00:16:10.739 Leon: Well, 1st of all, there is no standard library.

130 00:16:11.010 --> 00:16:13.529 Leon: There is no standard library under

131 00:16:13.900 --> 00:16:17.330 Leon: bare metal programming. You don't have any

132 00:16:18.100 --> 00:16:24.949 Leon: special library behind everything. You don't have the Lib. C. Or stuff to help you with.

133 00:16:25.070 --> 00:16:38.669 Leon: There are certain standard stuff there. There is a small standard library built into your code now, when you compile with no Std. But these are just basics

134 00:16:39.190 --> 00:16:48.579 Leon: and and no main, because, you know you're you feel free to select your entry point. For example, here. It's called my main.

135 00:16:48.760 --> 00:17:01.990 Leon: and it's it has the entry syntax here that marks it as entry point for this function. So when it builds, the Linker will arrange

136 00:17:02.130 --> 00:17:05.830 Leon: and the start of our code over here.

137 00:17:06.000 --> 00:17:10.809 Leon: So what you see here is some basic code for

138 00:17:12.598 --> 00:17:16.859 Leon: for a bare metal program in rust.

139 00:17:17.300 --> 00:17:20.852 Leon: Apart from the main, you have the

140 00:17:21.579 --> 00:17:28.689 Leon: the core panic panic info stuff which will be used for this function

141 00:17:28.800 --> 00:17:38.690 Leon: because we need to provide the panic function. This is the only function that we really have to provide apart from the entry function.

142 00:17:38.990 --> 00:17:41.750 Leon: And why do we need to provide panic.

143 00:17:42.000 --> 00:17:44.152 Leon: People familiar with

144 00:17:45.350 --> 00:17:54.397 Leon: with programming under an operating system are used to error handling to all kind of

145 00:17:55.560 --> 00:18:08.500 Leon: all kind of failures that are treated, whether in well, we, we are talking about runtime stuff right now. So at Runtime your program can fail in different ways.

146 00:18:08.990 --> 00:18:13.149 Leon: But in a bare metal embedded system.

147 00:18:13.650 --> 00:18:19.890 Leon: You don't have this luxury. You need to handle your panics by yourself.

148 00:18:20.370 --> 00:18:26.830 Leon: and when your code is about to panic you need to provide a handler to go into.

149 00:18:27.700 --> 00:18:32.799 Leon: and I'll just give you just just a thought. You know. Why.

150 00:18:33.690 --> 00:18:39.370 Leon: Why is this here? Why, the inline? Never for the panic handler

151 00:18:42.840 --> 00:18:48.959 Leon: any ideas, why cannot this function be inlined?

152 00:18:51.310 --> 00:18:58.189 Leon: The the reason for that is that this function will be called by a pointer.

153 00:18:58.650 --> 00:19:05.659 Leon: This function sits somewhere in the memory, and in case the CPU performs some illegal function

154 00:19:06.430 --> 00:19:19.190 Leon: like dividing by 0 or any other failure, then it will just jump over to the panic function. Now, inside panic function, it's up to you how to handle it.

155 00:19:19.590 --> 00:19:30.769 Leon: It's bare metal. You have no OS to look after. So you it's up to you. You can reset the platform, for example, or you can just do nothing and get stuck in the loop

156 00:19:30.950 --> 00:19:32.130 Leon: whatever you want.

157 00:19:32.590 --> 00:19:38.470 Leon: So this here is a very basic program for the cortex, M.

158 00:19:38.810 --> 00:19:39.839 Leon: And stuff.

159 00:19:40.280 --> 00:19:48.750 Leon: Now, how the things work with rust for bare metal programming with embedded rust for bare metal.

160 00:19:48.910 --> 00:19:54.790 Leon: 1st of all, you have the hardware, right? We all know Leds.

161 00:19:55.210 --> 00:20:01.379 Leon: And how do you control this hardware? Well, you can use direct register access.

162 00:20:02.410 --> 00:20:05.150 Leon: This is an example you use unsafe.

163 00:20:05.650 --> 00:20:12.039 Leon: and you write volatile, and this is the address

164 00:20:12.260 --> 00:20:18.120 Leon: right? And then you read volatile. Ptr. Read volatile from the same address.

165 00:20:18.250 --> 00:20:24.930 Leon: and then you perform an operation on it just to light up the relevant led.

166 00:20:25.060 --> 00:20:32.269 Leon: and then you write it back. So you read the value you modify it, and then you write it back to the memory.

167 00:20:32.650 --> 00:20:41.775 Leon: To do that you need to understand very well what you're doing, because this is just an address. It's just a re register in the

168 00:20:42.370 --> 00:20:52.548 Leon: in the in your mcu. So you you need to understand very well what you're doing here you need to read the the data sheets and

169 00:20:53.350 --> 00:20:55.329 Leon: figure out everything for yourself.

170 00:20:56.400 --> 00:21:07.640 Leon: The next level just above it is the pack, the peripheral access rate, this looks very different.

171 00:21:08.400 --> 00:21:13.090 Leon: 1st of all, you use the relevant pack.

172 00:21:13.260 --> 00:21:18.689 Leon: In this case I gave an example for an Stm. 32 F. 4.

173 00:21:19.070 --> 00:21:26.679 Leon: This is all open source and everything very accessible. You can check out the code inside whatever you want.

174 00:21:26.960 --> 00:21:31.870 Leon: So there you apply to Gpio

175 00:21:32.200 --> 00:21:36.800 Leon: a number A, which is the one of the Gpio sets.

176 00:21:36.980 --> 00:21:41.510 Leon: and then you have the output data register, and then you modify it

177 00:21:41.960 --> 00:21:46.250 Leon: alright, which is a method in Svd. To rust, which will

178 00:21:46.390 --> 00:21:48.939 Leon: we'll just mention in a second

179 00:21:49.844 --> 00:21:58.560 Leon: and then you just use the Odr 5 in this case, and you clear a bit.

180 00:22:00.030 --> 00:22:03.510 Leon: This makes more sense than what we've seen below.

181 00:22:04.100 --> 00:22:06.560 Leon: Now, what's the Svd to rust?

182 00:22:08.230 --> 00:22:23.299 Leon: well, most Mcu manufacturers provide Svd files that define the whole usage of their Gpios or the pins of the of the Mcu.

183 00:22:23.420 --> 00:22:33.619 Leon: And you can use the Svd to rust a tool to create the the packs.

184 00:22:33.720 --> 00:22:45.400 Leon: Okay, so packs can be created automatically, mostly. By just receiving the proper Svd file for the platform. So if you have your own

185 00:22:45.590 --> 00:22:56.750 Leon: like, you developed your own silicon, or a just have something that is not currently supported. As long as you have the Svd file, you're okay.

186 00:22:57.210 --> 00:23:03.900 Leon: You can get more information about it in Svd. To rust. Just type it on the net, and you'll find out.

187 00:23:05.430 --> 00:23:08.480 Leon: So this is nicer, but we can do better.

188 00:23:09.970 --> 00:23:19.200 Leon: One level above it is the hardware obstruction layer. How we'll know this this name

189 00:23:19.700 --> 00:23:25.870 Leon: and the how is way more convenient for us, as you can see here, we use the how.

190 00:23:25.970 --> 00:23:32.570 Leon: and we have the sample usage like Gpioa PA. 5,

191 00:23:32.800 --> 00:23:36.689 Leon: which was the Odr 5 over here.

192 00:23:36.970 --> 00:23:42.570 Leon: and maybe probably number Gpi. Number 5 over here

193 00:23:42.830 --> 00:23:51.129 Leon: into push, pull output. Okay? So we we 1st configure it to push, pull output. Then we set it to high.

194 00:23:51.480 --> 00:23:53.120 Leon: and that's it.

195 00:23:54.380 --> 00:24:01.140 Leon: Alright. So here, this is very, very straightforward, very convenient to use, and you have it all

196 00:24:01.530 --> 00:24:09.579 Leon: in the relevant hull crate like Stm. 32 f. Or xxl.

197 00:24:11.133 --> 00:24:31.049 Leon: But then you have the board support packages which are fantastic. The difference between how and the board support package is that the how allows you to work with the Mcu. So you select the Mcu and then you use its how.

198 00:24:31.200 --> 00:24:35.940 Leon: But board support packages is for is clearly for a board

199 00:24:36.597 --> 00:24:42.970 Gabor Szabo: Sorry for to interrupt you. I have a question. If it's okay, business layers.

200 00:24:44.680 --> 00:24:45.680 Gabor Szabo: Can you hear me?

201 00:24:45.840 --> 00:24:46.780 Leon: Yeah, yeah, I'm with you.

202 00:24:47.020 --> 00:24:48.340 Gabor Szabo: So so

203 00:24:49.230 --> 00:25:01.900 Gabor Szabo: are these examples really related, so meaning that there, there is the the lowest level the direct register access. You have this hexadecimal number?

204 00:25:02.030 --> 00:25:08.819 Gabor Szabo: Is the Odr actually correct? The Odr corresponds to that or so is there a name for basically

205 00:25:08.820 --> 00:25:09.600 Leon: Yes.

206 00:25:09.600 --> 00:25:10.090 Gabor Szabo: We'll go ahead

207 00:25:10.090 --> 00:25:15.680 Leon: Yes, yes, yes, under the hood. It works exactly like it's shown here.

208 00:25:15.970 --> 00:25:30.180 Leon: all right. Eventually everything boils down to these these commands, but they are just wrapped in layers of wrappers that allow you to use them in the easiest way possible.

209 00:25:31.220 --> 00:25:41.329 Gabor Szabo: Okay. So basically, the the what you can see then the on the pack level operation is basically doing the same reading and shifting and writing back

210 00:25:41.580 --> 00:25:42.779 Leon: Yes, exactly.

211 00:25:43.630 --> 00:25:45.360 Gabor Szabo: Is the clear bit? Okay.

212 00:25:45.510 --> 00:25:45.840 Leon: Yep.

213 00:25:45.840 --> 00:25:46.859 Gabor Szabo: Okay. Thank you.

214 00:25:47.660 --> 00:26:05.250 Leon: So the difference between the hull and the Bsp. Is because Bsp is about the board. So the actual board, like like this one over here. This is a board. It's a specific board that you can get and use.

215 00:26:05.370 --> 00:26:08.629 Leon: So if you have evaluation boards.

216 00:26:08.860 --> 00:26:13.760 Leon: many of these evaluation boards like the nucleo over here.

217 00:26:14.840 --> 00:26:25.820 Leon: You have the Bsp available for them. Now, why is it better to use the Bsp eventually, if you're using a

218 00:26:27.230 --> 00:26:33.810 Leon: an evaluation board. It's because here, for example, we can define an led.

219 00:26:34.920 --> 00:26:37.339 Leon: So when we define an led.

220 00:26:38.380 --> 00:26:52.280 Leon: and of course we configure it as appropriate, then you. You just have the on method for the led, because we know that this is an led. It's not just a Gpio.

221 00:26:52.630 --> 00:26:59.930 Leon: because we know that behind this specific Gpio on this specific board, we absolutely have an led.

222 00:27:00.220 --> 00:27:05.510 Leon: so we can configure it and just use the specific led with just an own command.

223 00:27:05.840 --> 00:27:08.540 Leon: and it makes the life very easy.

224 00:27:09.520 --> 00:27:10.465 Leon: And

225 00:27:11.550 --> 00:27:29.480 Leon: also, if you have your own board, if you develop your own board, then you can use some basic or some similar Bsps to define your own Bsp, and work, you know, like a king with this board very easy interface.

226 00:27:29.950 --> 00:27:37.040 Leon: So these are the layers of working with and

227 00:27:37.580 --> 00:27:43.445 Leon: and these are the layers of working with rust,

228 00:27:44.820 --> 00:27:47.700 Leon: With mcus in bare metal.

229 00:27:48.920 --> 00:27:51.620 Leon: Now, you know.

230 00:27:53.400 --> 00:28:02.520 Leon: And I use C. The C language in embedded development for for too long.

231 00:28:03.760 --> 00:28:12.279 Leon: And then, when I started, you know, considering this meetup, I just

232 00:28:13.250 --> 00:28:21.029 Leon: did a test. I just went to the Internet, you know, on Google and wrote cross compilation setup in C,

233 00:28:22.340 --> 00:28:26.969 Leon: and the 1st thing it brought me to was

234 00:28:27.290 --> 00:28:45.490 Leon: stack overflow cross compilation requirements. I have some basic knowledge about compiling with C need to get a couple of generic cross compilation questions answered. In my case, I'm trying to whatever and this and that, and there were lots of sections like that, and no real good explanation.

235 00:28:45.900 --> 00:28:53.320 Leon: If you do the same in rust, you immediately arrive to the right place, to the right

236 00:28:53.540 --> 00:29:00.600 Leon: website and to the right page. That explains you exactly how to build everything you need.

237 00:29:01.230 --> 00:29:09.680 Leon: And this is just fantastic. This is why rust is a modern programming language. Unlike C,

238 00:29:12.120 --> 00:29:16.249 Leon: we can talk a lot about that, but we will, we will not right now.

239 00:29:16.510 --> 00:29:22.510 Leon: Still, the picture is clear. I clearly feel the difference here.

240 00:29:24.060 --> 00:29:33.189 Leon: Yeah, this is just some fun poster I made for explaining my feelings.

241 00:29:33.420 --> 00:29:37.449 Leon: Yes, C. Is quite confusing at times.

242 00:29:37.590 --> 00:29:45.570 Leon: Rust is way more straightforward, so you can be ready to go. Oh, sorry to rust in 5 min.

243 00:29:45.800 --> 00:29:47.190 Leon: maybe less.

244 00:29:47.400 --> 00:29:53.539 Leon: It's all up to you. You install the cross compiler and set up a project that's all.

245 00:29:53.920 --> 00:30:00.120 Leon: So rust up target, add you add your own target depends on what you work with.

246 00:30:00.400 --> 00:30:03.190 Leon: Then you create the project.

247 00:30:04.090 --> 00:30:15.740 Leon: Then you go into your project. Then you cargo. Ed, for example, in this case it's cortex, and there are different targets. We will mention Rtt. Very soon.

248 00:30:16.700 --> 00:30:21.559 Leon: and that's about it. You're ready to to work

249 00:30:22.310 --> 00:30:27.499 Leon: now, you code it. You set it up. You set it up for the target, and then

250 00:30:28.450 --> 00:30:30.860 Leon: then the fun part begins, because.

251 00:30:31.310 --> 00:30:38.230 Leon: unlike with C or any other language, well, most of other languages I'm familiar with.

252 00:30:39.939 --> 00:30:44.520 Leon: You check it, build it, flash it, debug it.

253 00:30:44.730 --> 00:30:49.999 Leon: and even more stuff you can do with it like Rtt. Eat

254 00:30:50.160 --> 00:30:54.119 Leon: and so on, just with one single command.

255 00:30:54.510 --> 00:30:56.409 Leon: It's cargo and bed.

256 00:30:57.010 --> 00:31:19.039 Leon: You don't have to use it. But this is a wonderful command. And once again I'm mentioning this is a great ecosystem to start working with embedded development with bare metal. It's cargo embed. You specify the target or you can specify it in the configuration file. And that's it. You just type cargo embed, and it's already there.

257 00:31:19.250 --> 00:31:20.770 Leon: We'll see it in a second.

258 00:31:21.470 --> 00:31:30.469 Leon: So cargo is really, I really believe that it's the marvel of modern development. It's incredible.

259 00:31:30.650 --> 00:31:36.530 Leon: You, it allows you to create new projects very quickly with git built in.

260 00:31:36.680 --> 00:31:44.309 Leon: you add and manage crates and utilities. You have a simplified, efficient builds because well.

261 00:31:44.540 --> 00:31:55.150 Leon: when you use it, you know the integrated testing framework inside automatically generate the documentation. You want seamless, embedded workflow.

262 00:31:55.370 --> 00:32:00.199 Leon: very easy, manage multiple related packages.

263 00:32:00.440 --> 00:32:01.370 Leon: There are.

264 00:32:02.690 --> 00:32:12.529 Leon: Cargo is a fantastic tool, especially for the beginners. It allows you to do everything quickly and very, very efficiently.

265 00:32:12.650 --> 00:32:20.600 Leon: You really should read into the cargo abilities, because well, I do believe many of you have used cargo in past, but

266 00:32:21.710 --> 00:32:29.580 Leon: many of us rust developers are not quite aware about the whole list of

267 00:32:30.330 --> 00:32:34.820 Leon: things you can do with cargo. It's a very nice reading.

268 00:32:36.020 --> 00:32:41.759 Leon: So before we jump to some code, any questions.

269 00:32:43.920 --> 00:32:44.930 Leon: That's nice.

270 00:32:46.000 --> 00:32:49.639 Leon: Oh, that's from the meetup. We had refreshments there.

271 00:32:53.060 --> 00:32:55.549 Leon: Because I'm going to show you some code.

272 00:32:58.880 --> 00:32:59.880 Leon: And.

273 00:33:00.630 --> 00:33:17.039 Leon: by the way, you can check out all the examples here because we will. We don't have much time for the examples. But you can use this repo I created just for the sake of this meetup. I will.

274 00:33:19.280 --> 00:33:26.410 Leon: Here is the chat. I will put it through right here, so you can access it all right.

275 00:33:27.280 --> 00:33:34.150 Leon: Good. So we have this code over here.

276 00:33:34.640 --> 00:33:39.439 Leon: and let's let me see. All right. So we have the 1st example here. Now.

277 00:33:39.440 --> 00:33:42.209 Gabor Szabo: Enlarge a little. Sorry. Can you enlarge a little bit? The font

278 00:33:42.630 --> 00:33:46.599 Leon: No, of course I can. Just a second

279 00:33:47.380 --> 00:33:50.020 Gabor Szabo: It's embedded. You can't enlarge the phones

280 00:33:50.925 --> 00:34:01.540 Leon: Alright, so we're good all right. So

281 00:34:02.650 --> 00:34:11.650 Leon: let's see. So this is the 1st example. I believe this. It will be the most important one we have the main

282 00:34:11.909 --> 00:34:15.960 Leon: here. So, as we said, no Std and no main.

283 00:34:16.449 --> 00:34:21.187 Leon: then we import. We use a cortex, m,

284 00:34:22.199 --> 00:34:24.449 Leon: and we don't really use it.

285 00:34:24.560 --> 00:34:29.120 Leon: Why do we do this, then, for default, critical section implementation.

286 00:34:29.820 --> 00:34:37.310 Leon: And when we are not using the micro bit create. We will be working with this M.

287 00:34:37.420 --> 00:34:48.369 Leon: With this board called Micro bit. It's from. It's by BBC, you can check it out and you have some. I believe you. You even have links in the in the repo.

288 00:34:48.550 --> 00:34:54.909 Leon: and this is just a board with few Leds and stuff on it, and

289 00:34:55.219 --> 00:34:58.379 Leon: and it's very easy to use. Very cheap.

290 00:34:58.550 --> 00:35:00.650 Leon: Very nice for beginners.

291 00:35:01.624 --> 00:35:14.789 Leon: So yeah. So we have the when we are not using the micro bit crate, and we don't hear. So we are not like using hull or a a Bsp.

292 00:35:15.130 --> 00:35:22.549 Leon: but we are using cortex M, so we are applying directly to the CPU of cortex. M,

293 00:35:22.700 --> 00:35:27.840 Leon: we're using the entry point and we have the rtt.

294 00:35:28.455 --> 00:35:33.849 Leon: the panic. Rt target simply brings us the panic section that we don't.

295 00:35:34.422 --> 00:35:44.300 Leon: We don't need to create it manually, it does it for us. So when you use this panic, then it will just add the handler function for you.

296 00:35:44.560 --> 00:35:54.579 Leon: and then Rt, rtt, well, I don't remember the abbreviation, but Rtt is just the Prince.

297 00:35:54.700 --> 00:36:06.210 Leon: This is a protocol by seger, and used for debugging over different debuggers, and you will immediately see how it works.

298 00:36:06.620 --> 00:36:09.840 Leon: So we have our entry function.

299 00:36:10.540 --> 00:36:13.079 Leon: We have the Rtt. Init print.

300 00:36:13.810 --> 00:36:22.350 Leon: so initialize it for printing print a hello message to the rt, just like our print line. This is the function.

301 00:36:22.620 --> 00:36:26.960 Leon: and that's it. And then we're stuck in the loop forever.

302 00:36:27.230 --> 00:36:32.170 Leon: Now, how do we actually build it and work with it?

303 00:36:32.670 --> 00:36:33.870 Leon: It's quite easy.

304 00:36:34.090 --> 00:36:45.180 Leon: I go into the example. One directory am cargo embed.

305 00:36:46.970 --> 00:36:50.850 Leon: This is everything we need to just build it and run it.

306 00:36:51.120 --> 00:36:57.670 Leon: It it it built it, flashed it, and ran it just for us.

307 00:36:57.850 --> 00:37:05.830 Leon: So we have. Hello from micro bit, and this is the output of the Rtt. Interface

308 00:37:08.330 --> 00:37:09.789 Leon: as easy as that

309 00:37:10.490 --> 00:37:12.560 Gabor Szabo: It's connected with a USB, right?

310 00:37:13.360 --> 00:37:18.359 Leon: Yeah, it's connected with USB, and it creates 2 serial ports on the system.

311 00:37:18.870 --> 00:37:27.330 Leon: Okay, so this is all. Going through a serial Port M.

312 00:37:27.630 --> 00:37:33.040 Leon: Maybe you can even see the port over here. No, you cannot, whatever.

313 00:37:33.850 --> 00:37:43.270 Leon: Right? So now let's take something more interesting. You know we are all embedded guys. We like seeing Leds

314 00:37:43.660 --> 00:37:45.580 Leon: on and off, right?

315 00:37:46.250 --> 00:37:52.639 Leon: So here we have the matrix. And now here I already start using the micro bit crate.

316 00:37:52.980 --> 00:37:54.820 Leon: This is the Bsp.

317 00:37:55.310 --> 00:38:01.509 Leon: okay, so it allows me to use the board in the in a very, very easy way.

318 00:38:02.030 --> 00:38:08.190 Leon: For example. Well, you you can see just some sort of array over here.

319 00:38:08.940 --> 00:38:13.669 Leon: and this is a kind of irrelevant function. We will not go into it.

320 00:38:13.910 --> 00:38:16.500 Leon: But then, what what do we do here.

321 00:38:16.620 --> 00:38:19.689 Leon: Just look how simple the code is.

322 00:38:20.020 --> 00:38:25.289 Leon: Board. Take. Okay, so we initialize the board.

323 00:38:25.420 --> 00:38:28.700 Leon: Then we initialize a timer because we need a timer here.

324 00:38:28.920 --> 00:38:31.920 Leon: So we use the timer 0 of this board.

325 00:38:32.380 --> 00:38:44.860 Leon: and we need the display, the display in this case, because this is bsp, so it has a display, for, as you can see, here, you have the Leds and metric matrix of Leds.

326 00:38:45.410 --> 00:38:54.430 Leon: So now you just loop through the matrix just by creating display show, and then

327 00:38:56.140 --> 00:39:04.089 Leon: and that's about it. You just have the display show function that you display the the array. So let's

328 00:39:05.680 --> 00:39:10.350 Leon: let's run it. No, not here. City X.

329 00:39:11.400 --> 00:39:14.850 Leon: Example 2 cargo and bed.

330 00:39:22.560 --> 00:39:25.330 Leon: Alright. Now, what do we see here?

331 00:39:26.340 --> 00:39:27.910 Leon: Hey?

332 00:39:28.960 --> 00:39:31.879 Leon: This is the best moment in my career.

333 00:39:33.870 --> 00:39:43.460 Leon: Alright! So we have successfully and created a lit carousel.

334 00:39:44.030 --> 00:39:49.200 Leon: Now I want to show you just a bit inside of how the things work

335 00:39:49.330 --> 00:39:54.880 Leon: and what what files do you need to use to make this all happen.

336 00:39:56.330 --> 00:40:02.489 Leon: Unlike with simple rust that you use with an operating system.

337 00:40:03.190 --> 00:40:09.560 Leon: Here, apart from your main, you have a few things. Let's start with the standard things.

338 00:40:09.680 --> 00:40:11.739 Leon: cargo.com.

339 00:40:12.240 --> 00:40:19.399 Leon: It just includes the libraries and everything. I mean the crates we have here. Everything is quite standard.

340 00:40:19.580 --> 00:40:28.324 Leon: Alright. Don't forget about the features using cortex, M. Critical section inline awesome. And so you need to

341 00:40:30.190 --> 00:40:31.620 Leon: to to get them in.

342 00:40:32.120 --> 00:40:39.670 Leon: But then you have 2 additional files which are very important.

343 00:40:39.900 --> 00:40:41.900 Leon: You have the build dot Rs.

344 00:40:42.510 --> 00:40:55.919 Leon: the build dot. Rs script is quite standard. It's not special for every project you don't have to change it, but you might want to change it eventually. I will not just go through everything here.

345 00:40:56.380 --> 00:41:01.980 Leon: It's quite clear, but not a very obvious from the start.

346 00:41:02.430 --> 00:41:09.490 Leon: It simply makes sure that your Linker would will take this Linker script.

347 00:41:09.790 --> 00:41:20.240 Leon: because, as usual, with a embedded developer embedded development on Mcus. You need to specify some

348 00:41:20.870 --> 00:41:29.070 Leon: initial data for the Mcu to run. So here it's quite simple. You have the flash memory, and you have the RAM

349 00:41:29.680 --> 00:41:30.770 Leon: very easy.

350 00:41:32.200 --> 00:41:40.989 Leon: and the build dot Rs simply makes sure that this is the file that's used by the Linker.

351 00:41:42.590 --> 00:41:50.390 Leon: and the last thing. Oh, not the last one, actually. But let's look at it.

352 00:41:50.530 --> 00:41:53.070 Leon: The embed dot tunnel.

353 00:41:53.450 --> 00:42:03.250 Leon: This file is actually specifies everything. What everything you do with cargo embed the cargo embed command

354 00:42:03.640 --> 00:42:05.270 Leon: deals with this file

355 00:42:05.420 --> 00:42:12.060 Leon: so you can set up the default protocol here, like currently your probe is single wire debugging.

356 00:42:13.300 --> 00:42:18.189 Leon: You can also specify Jtag. It depends on your debugger. You just specify it over here.

357 00:42:18.980 --> 00:42:25.529 Leon: Then you have the general settings for the target, like, for example, you need to specify what

358 00:42:25.750 --> 00:42:27.119 Leon: chip you're using.

359 00:42:27.640 --> 00:42:35.550 Leon: So in our case, this is the Nordic chip. Nrf, whatever you need to get this information from the

360 00:42:37.110 --> 00:42:39.649 Leon: from the Gp you're using right.

361 00:42:40.210 --> 00:42:43.210 Leon: and you so you can specify chip models.

362 00:42:43.340 --> 00:42:50.520 Leon: The default reset operation here is that you can halt after flashing.

363 00:42:50.900 --> 00:42:52.740 Leon: Why is it useful?

364 00:42:53.130 --> 00:42:58.649 Leon: When is it useful to halt after flashing and stop the program from running.

365 00:42:59.100 --> 00:43:00.969 Leon: It's during your debug.

366 00:43:01.710 --> 00:43:02.670 Leon: Okay?

367 00:43:03.850 --> 00:43:10.769 Leon: And then, you have the default. Rt, which is either enabled or not.

368 00:43:11.040 --> 00:43:18.009 Leon: For example, in this case I don't use Rtt. At all. There was no rtt in my code.

369 00:43:19.190 --> 00:43:20.230 Leon: any of it.

370 00:43:20.760 --> 00:43:23.859 Leon: So why did I enable Rtt, anyway?

371 00:43:24.180 --> 00:43:34.470 Leon: Because and why do I initialize it, anyway? Because for debugging, I still use Rtt Target target. And

372 00:43:35.020 --> 00:43:39.589 Leon: yeah, the panic target. So if I get any panic. It would print me

373 00:43:39.830 --> 00:43:44.049 Leon: something on rtt, so I will know I have a panic in my code.

374 00:43:44.880 --> 00:43:53.840 Leon: but I can drop it. Okay. So, for example, if I change it here to false, and I

375 00:43:55.410 --> 00:44:02.730 Leon: and I build it again and run it, you will see that Rtt. Is no longer enabled on start.

376 00:44:04.360 --> 00:44:09.620 Leon: Okay, the the the board is still running, of course.

377 00:44:10.340 --> 00:44:11.280 Leon: That's it.

378 00:44:12.080 --> 00:44:13.550 Leon: M.

379 00:44:14.150 --> 00:44:18.950 Leon: You also have the default. Gdb, and note this. It's enabled.

380 00:44:19.590 --> 00:44:21.680 Leon: The Gdb. Is enabled here.

381 00:44:22.400 --> 00:44:40.040 Leon: and and you can specify the port. Let's get to Gdb. No worries and default flashing. Of course you can enable the default flashing, but you can. If you have a different flashing algorithm or program, you just specify it here. No worries at all. It's all very configurable.

382 00:44:40.960 --> 00:44:44.720 Leon: Now let's look on the

383 00:44:46.080 --> 00:44:47.630 Leon: Gdb stuff.

384 00:44:47.940 --> 00:44:56.499 Leon: So we are here, and I will quickly. Start the debugging.

385 00:44:58.290 --> 00:45:04.270 Leon: so I will just copy and paste some commands. It will not annoy you, M.

386 00:45:04.940 --> 00:45:09.579 Leon: I'm running the Gdb multi arc with my target. Executable.

387 00:45:11.820 --> 00:45:20.709 Leon: Alright. So I'm inside. Gdb, now with my target. Now I want to connect to my remote, which is by default

388 00:45:20.830 --> 00:45:22.119 Leon: on this port

389 00:45:22.630 --> 00:45:25.209 Gabor Szabo: We're doing a lot of the phones here, too. Please

390 00:45:25.210 --> 00:45:28.329 Leon: I don't know. Maybe let's see. Yes.

391 00:45:28.860 --> 00:45:31.209 Leon: Now I will need to.

392 00:45:32.620 --> 00:45:33.360 Leon: Yeah.

393 00:45:34.060 --> 00:45:34.670 Gabor Szabo: Thanks.

394 00:45:37.100 --> 00:45:39.890 Leon: All right, M.

395 00:45:40.370 --> 00:45:44.254 Leon: And now and now I can.

396 00:45:45.290 --> 00:45:55.719 Leon: I believe it does it by by itself. But I source the Gdb. In. It doesn't matter I will just configure the dashboard a little bit.

397 00:45:57.350 --> 00:45:58.480 Leon: Okay.

398 00:45:58.630 --> 00:46:06.120 Leon: And let's have a and didn't I?

399 00:46:08.620 --> 00:46:11.169 Leon: That's kind of strange.

400 00:46:11.970 --> 00:46:14.659 Leon: Okay. No, wait.

401 00:46:16.691 --> 00:46:20.200 Leon: Yes, let's start it again.

402 00:46:21.370 --> 00:46:25.559 Leon: Oh, yes, right? Right? Right? Right? So that's the problem.

403 00:46:25.970 --> 00:46:31.509 Leon: Let's see. Where am I? Target?

404 00:46:33.570 --> 00:46:34.175 Leon: Yeah.

405 00:46:35.900 --> 00:46:38.220 Leon: Okay, debug.

406 00:46:39.460 --> 00:46:43.780 Leon: And hmm.

407 00:46:47.940 --> 00:46:51.570 Leon: okay, all right, all right. All right.

408 00:46:51.740 --> 00:46:54.710 Leon: So where were we in

409 00:47:02.520 --> 00:47:06.030 Leon: and breakpoint?

410 00:47:06.910 --> 00:47:11.299 Leon: Yeah, the program is not being run.

411 00:47:11.740 --> 00:47:13.739 Leon: What's going on?

412 00:47:16.180 --> 00:47:25.700 Leon: This is what happens when you try to show something quickly the exact format error.

413 00:47:30.730 --> 00:47:32.510 Leon: That's strange.

414 00:47:34.050 --> 00:47:36.960 Leon: Let's try something else.

415 00:47:53.600 --> 00:47:57.630 Leon: Something is wrong about it.

416 00:47:58.020 --> 00:48:14.219 Leon: Well, I will not. Continue with this direction, because I will waste all your time, and I still want to show you stuff. But, generally speaking, debugging is quite easy, because you have the debugging built in already.

417 00:48:14.540 --> 00:48:20.050 Leon: Alright, so you can simply connect and debug your code.

418 00:48:20.250 --> 00:48:26.780 Leon: And it's all very convenient, because you don't need to even add another line over there.

419 00:48:27.060 --> 00:48:45.689 Leon: And one more thing to mention is that in config dot tunnel you can specify how to work with. Your specific configuration like in this case. I've configured it all arm and target OS, and so on. Use

420 00:48:46.100 --> 00:48:49.860 Leon: the Linker script the specific Linker script.

421 00:48:50.398 --> 00:48:57.150 Leon: That's quite easy, or you can provide your own specific target if you want really up to you.

422 00:48:57.290 --> 00:49:06.119 Leon: So these are the main files that you have here. We mentioned the embed, the tumul, the most important file for cargo embed.

423 00:49:06.240 --> 00:49:15.049 Leon: We have the cargo standard and the bill dot Rs. Which selects the Linker script.

424 00:49:15.250 --> 00:49:17.070 Leon: and the Linker script itself.

425 00:49:17.690 --> 00:49:22.539 Leon: That's everything we need to get going, and it's all available on the net.

426 00:49:23.751 --> 00:49:37.039 Leon: Just another example. Here, let's say and then see the and let's take

427 00:49:37.200 --> 00:49:46.100 Leon: example for the accelerometer and cargo embed.

428 00:50:02.390 --> 00:50:03.220 Leon: Yep.

429 00:50:03.820 --> 00:50:10.549 Leon: So now we have the values from the accelerometer on this board, so you can see the values

430 00:50:10.820 --> 00:50:13.559 Leon: are changing in the 3 directions.

431 00:50:14.420 --> 00:50:22.879 Leon: And yeah, and how you achieve this thing quite easily.

432 00:50:23.400 --> 00:50:30.470 Leon: And you have the the code right here in front of you.

433 00:50:30.640 --> 00:50:38.522 Leon: So, and you have the from microbeat you get the

434 00:50:39.874 --> 00:50:45.109 Leon: twi interface, the uart interfaces, timers, and everything.

435 00:50:45.710 --> 00:50:54.900 Leon: Then in this case you initialize the board itself as usual. Board. Take, then, you initialize timer.

436 00:50:55.500 --> 00:50:57.290 Leon: You have the serial.

437 00:50:57.820 --> 00:51:06.070 Leon: You are new, as you can see, very everything is very straightforward here, right? It's the simplest thing you can think about to

438 00:51:06.220 --> 00:51:09.709 Leon: initialize a serial interface.

439 00:51:09.960 --> 00:51:15.809 Leon: and then you set up the I square C interface the the 2 wire interface

440 00:51:16.310 --> 00:51:21.359 Leon: right also, as you can see, very easy for supply frequency, and that's about it.

441 00:51:21.750 --> 00:51:27.540 Leon: And then here, in this case, it has a sensor called Lsm. 303,

442 00:51:27.890 --> 00:51:34.160 Leon: and for which we have a separate crate, which is totally a totally unrelated crate.

443 00:51:34.330 --> 00:51:36.749 Leon: But it provides us access.

444 00:51:36.890 --> 00:51:38.139 Leon: Who the censor?

445 00:51:39.340 --> 00:51:44.559 Leon: We initialize the sensor. We set the accelerator mode, and so on.

446 00:51:44.830 --> 00:51:52.399 Leon: and then, for we delay for 50. We sleep for 50 ms.

447 00:51:53.610 --> 00:51:56.240 Leon: and then we have the acceleration.

448 00:51:56.960 --> 00:52:02.539 Leon: We are reading the acceleration in one command, one simple command over I square C,

449 00:52:04.090 --> 00:52:09.739 Leon: and that's about it. We write it to the serial line, and then we r print. Line it as well.

450 00:52:10.110 --> 00:52:16.700 Leon: Now I wanted to show you the prints from the serial line. However.

451 00:52:16.800 --> 00:52:22.220 Leon: it seems like I have some issue here

452 00:52:25.250 --> 00:52:35.769 Leon: at the moment, because when I connect to the serial line I see nothing, and that's the quite weird.

453 00:52:36.060 --> 00:52:45.029 Leon: I don't know. I see. M. 0. This is the this is the interface, but

454 00:52:45.470 --> 00:52:51.270 Leon: I see nothing on it. So hmm!

455 00:52:53.740 --> 00:52:59.090 Leon: I think I know why I think I know why

456 00:53:04.080 --> 00:53:07.490 Leon: PTYA. CM. 0 am

457 00:53:12.823 --> 00:53:13.456 Leon: sorry.

458 00:53:20.710 --> 00:53:30.349 Leon: I think I know why DTYA. CM. 0, and then.

459 00:53:35.780 --> 00:53:36.870 Leon: and

460 00:53:44.330 --> 00:53:47.530 Leon: I think it was 1,200.

461 00:53:48.090 --> 00:53:49.350 Leon: Let's see.

462 00:53:51.610 --> 00:53:52.690 Leon: Okay?

463 00:53:56.540 --> 00:54:03.749 Leon: Oh, hey, I got training. So it was configured for a different bowed rate or wrong bout rate.

464 00:54:04.890 --> 00:54:09.540 Leon: So you can see that now it prints to the serial interface

465 00:54:09.780 --> 00:54:14.180 Leon: I'm connected over minicom, and then you can also see.

466 00:54:14.400 --> 00:54:17.849 Leon: And you can also see it over here.

467 00:54:18.340 --> 00:54:21.130 Leon: and I closed it. So I need to

468 00:54:21.460 --> 00:54:24.279 Leon: suppose I need to rerun it. But whatever?

469 00:54:24.690 --> 00:54:35.689 Leon: And yeah, so in this way. As you can see, printing to the serial port

470 00:54:36.410 --> 00:54:40.840 Leon: could not be simpler than with rust here, and

471 00:54:41.040 --> 00:54:51.537 Leon: and I remember my initial projects in C with embedded with St. Micro electronics Mcus, and with

472 00:54:52.360 --> 00:54:57.460 Leon: ziologue and such. It was a nightmare here, you know.

473 00:54:58.880 --> 00:55:08.409 Leon: very easy and straightforward. So my my point in this presentation, because we need to wrap up.

474 00:55:09.610 --> 00:55:13.886 Leon: The main thing I'm trying to

475 00:55:15.580 --> 00:55:17.929 Leon: to to show here is that

476 00:55:18.290 --> 00:55:22.880 Leon: 1st of all, the trust is a very modern

477 00:55:23.080 --> 00:55:28.349 Leon: language and ecosystem for developing for bare metal.

478 00:55:29.260 --> 00:55:32.559 Leon: It's very convenient. It's very

479 00:55:34.510 --> 00:55:36.099 Leon: It's very mature.

480 00:55:36.630 --> 00:55:46.920 Leon: It's not like. It's something that you need to, you know. Spend your nights on configuring.

481 00:55:47.380 --> 00:55:51.720 Leon: It's mature. You just install it and run it. It's very straightforward.

482 00:55:53.900 --> 00:55:58.460 Leon: more. Moreover, if you need.

483 00:55:58.900 --> 00:56:02.860 Leon: you know, in in my view, if you want to. To.

484 00:56:03.340 --> 00:56:09.739 Leon: To begin working with bare metal programming today with mcus.

485 00:56:10.350 --> 00:56:12.470 Leon: I think that there is no

486 00:56:12.730 --> 00:56:19.819 Leon: reason to choose C over rust at all, because rust will

487 00:56:19.970 --> 00:56:25.420 Leon: rust and cargo will provide you everything you need get going, and

488 00:56:25.580 --> 00:56:35.359 Leon: in a in a safe memory, safe way. So why bother even dealing with sea and whatever?

489 00:56:35.540 --> 00:56:44.768 Leon: So if you have a new project for bare metal machines. There is absolutely no reason to choose

490 00:56:45.730 --> 00:56:49.169 Leon: to choose C over us. That's about it.

491 00:56:50.090 --> 00:56:57.130 Leon: So, Gabbara. I'm quite done. I have. I didn't show everything, but we were. We're out of time

492 00:56:58.190 --> 00:57:01.009 Leon: You you guys can use the repo to

493 00:57:01.120 --> 00:57:03.370 Leon: to check out the rest of the things

494 00:57:04.890 --> 00:57:19.930 Gabor Szabo: Okay. So I'll 1st of all, thank you very much. I just checked. I had this micro bit that I bought like a year ago, and I still didn't do anything with it. It's version 2. So I'll have to see if if this code I see that

495 00:57:19.930 --> 00:57:24.675 Leon: Well, well, this for version 2, as you can see.

496 00:57:26.080 --> 00:57:34.010 Leon: over here, I think. I put it year. Yes.

497 00:57:34.220 --> 00:57:47.210 Leon: So over here you can we work for version 1 1.5. Use with this one for the version, 2 works with 7

498 00:57:47.370 --> 00:57:48.439 Leon: v. 7

499 00:57:48.650 --> 00:57:49.390 Gabor Szabo: Okay.

500 00:57:49.390 --> 00:57:50.559 Leon: That's the difference.

501 00:57:51.280 --> 00:58:05.380 Leon: And by the way, you can find a lot about it on the Internet, it's all there. You just type in. Oh, by the way, I want to even show you how it works. You see, you go into rust for embedded.

502 00:58:06.060 --> 00:58:11.460 Leon: and you reach the embedded Rust book, I really.

503 00:58:11.670 --> 00:58:25.830 Leon: I really like the the documentation in Rust for embedded because when I started with embedded programming there was no such thing for C. There are plenty of C books.

504 00:58:26.020 --> 00:58:31.130 Leon: but nothing close to to stuff like this.

505 00:58:31.940 --> 00:58:38.819 Leon: So you have the embedded rust manuals here for everything, you know

506 00:58:39.110 --> 00:58:45.689 Leon: whatever. And then you have the bare metal rust section, which is very specific

507 00:58:45.860 --> 00:58:54.510 Leon: with all the installations and explanations about how to set things up for different operating systems, and so on.

508 00:58:55.420 --> 00:59:05.319 Leon: And then, for example, the discovery here section, it's all about specifically about the micro bit

509 00:59:06.040 --> 00:59:13.420 Leon: alright. This is the everything here in discovery is about micro bit. And here is just another example of

510 00:59:13.600 --> 00:59:15.490 Leon: working with Stm.

511 00:59:15.980 --> 00:59:23.190 Leon: 32 specific board. Everything is just like with all the examples and everything

512 00:59:23.500 --> 00:59:26.470 Leon: very clear, very straightforward, and so on.

513 00:59:29.860 --> 00:59:30.840 Gabor Szabo: Excellent.

514 00:59:32.050 --> 00:59:46.409 Gabor Szabo: So thank you very much if anyone has any questions who wants to still ask it during the presentation. But we didn't have, through all the presentation. Maybe you have something now, and do go ahead and ask.

515 00:59:46.800 --> 00:59:47.960 Gabor Szabo: and

516 00:59:48.960 --> 01:00:14.850 Gabor Szabo: if not, then we are going to shut down the the recording, and then you can, because you are here. You have this privilege that you can stay around, and then we can have a continue the discussion. If you're watching on the Youtube. Then you have the privilege to click the like button and follow the channel. And so, Leon, thank you very much for this presentation, and thanks everyone for

517 01:00:14.960 --> 01:00:22.680 Gabor Szabo: and for attending, and so hope to see you soon at a different presentation.

518 01:00:22.960 --> 01:00:23.830 Gabor Szabo: Bye, bye.

Frans Slabber

Transcript

1 00:00:00.570 --> 00:00:02.170 Frans: This meeting is being recorded

2 00:00:02.170 --> 00:00:15.080 Gabor Szabo: So Hi, and welcome to the codeme events meetings, the meet up group. And if you're watching the Youtube video, then to the codeme events, Youtube Channel. And my name is Gabor Sabo. I

3 00:00:15.270 --> 00:00:23.110 Gabor Szabo: I'm a self-employed. I help companies introduce rust and python, help them with training, help them with testing.

4 00:00:23.220 --> 00:00:35.710 Gabor Szabo: And I also organize events, both in person meetings in Tel, Aviv, and in Python for Python and and Rust, and also these online events in English.

5 00:00:36.290 --> 00:00:50.500 Gabor Szabo: in order to share knowledge between people all around the world. And I think it's a very good way to learn about all kind of things that we can't learn or ourselves

6 00:00:50.660 --> 00:01:08.890 Gabor Szabo: this time. We have Franz, who agreed to give this presentation, and you're going to introduce yourself, or he's going to introduce himself in a bit. I'm really happy that you agreed to give this presentation, and I thank everyone who joined us in this meeting

7 00:01:08.890 --> 00:01:25.200 Gabor Szabo: feel free to ask questions after the recording, we can stay around. So if there are things that you don't want to talk about during the recording and in the Youtube, video, that's fine, we can stay around after the meeting and have a little chat as well. That's the

8 00:01:25.230 --> 00:01:28.480 Gabor Szabo: advantage of actually being in the in the meeting.

9 00:01:28.710 --> 00:01:31.369 Gabor Szabo: And also you can ask questions.

10 00:01:32.320 --> 00:01:47.709 Gabor Szabo: and if you're watching the video, then please click the like button and follow the channel. So you get notified and also join our the call me events meet up group, so you will be able to see when we have a new meetings.

11 00:01:48.430 --> 00:01:53.809 Gabor Szabo: Franz. Welcome to this meeting. Please introduce yourself, and it's yours.

12 00:01:54.540 --> 00:01:57.089 Gabor Szabo: Share your screen, if you like, and whatever

13 00:01:57.090 --> 00:02:01.689 Frans: Yeah, thanks. Thanks. Kabor. And thanks for the opportunity.

14 00:02:02.283 --> 00:02:11.110 Frans: As as I just mentioned to you. Unfortunately, I've I've I haven't got a formal presentation. But I will talk through

15 00:02:11.230 --> 00:02:24.920 Frans: this sort of process that went into what I'm doing. So 1st of all, my name is Franz Bresler slabber. That's the full spectrum of names. And I'm a programmer living in South Africa.

16 00:02:25.370 --> 00:02:30.309 Frans: I've been a programmer since I can't remember

17 00:02:30.570 --> 00:02:49.090 Frans: since 94 mainly and and oh, okay, I work for myself as well. So I do various contracts, developing mainly in the technical sort of programming space solving.

18 00:02:49.620 --> 00:02:53.009 Frans: modeling problems, etc, stuff like that.

19 00:02:54.810 --> 00:03:00.240 Frans: So my main expertise has always been c plus plus.

20 00:03:00.930 --> 00:03:19.600 Frans: Recently I had moved into Golang a bit, and then I sort of out of interest started in rust. So rust is almost I haven't. How can I say? Used it commercially, but it's it's an interest, and it's a fascinating way for me to.

21 00:03:19.810 --> 00:03:23.493 Frans: I've got a strong interest in mathematics.

22 00:03:24.270 --> 00:03:34.070 Frans: especially how it relates to a numerical computing for use in in machine learning and stuff like that

23 00:03:34.230 --> 00:03:35.530 Frans: stuff like that

24 00:03:37.020 --> 00:03:48.970 Frans: very technical term. Okay, so 1st order of business, what I did is I'm gonna share screen, because I think that's the easiest way to to go about this. That's okay. Gabor.

25 00:03:49.230 --> 00:03:50.300 Frans: obviously.

26 00:03:50.300 --> 00:03:52.039 Gabor Szabo: Sure. Sure. Sure. Go ahead.

27 00:03:52.240 --> 00:03:55.820 Frans: Okay. So I'm not too familiar.

28 00:03:58.220 --> 00:04:00.240 Gabor Szabo: Should be a big green button

29 00:04:00.240 --> 00:04:01.989 Frans: Yeah, yeah, I've got it.

30 00:04:02.870 --> 00:04:10.210 Frans: Share. Oh, yeah. Oh, not seeing it. Select window. So I'm gonna select.

31 00:04:11.310 --> 00:04:16.779 Frans: Not that one know what that doing open store.

32 00:04:17.060 --> 00:04:25.299 Frans: allow visual studio. So I've got a very big screen. So please tell me if the resolution is okay.

33 00:04:25.300 --> 00:04:30.200 Gabor Szabo: But way too small the letters. So if you can enlarge the fonts, that would be nice

34 00:04:30.380 --> 00:04:34.192 Frans: Yeah, I can just zoom in. I think that works as well.

35 00:04:34.990 --> 00:04:36.410 Frans: Just a moment.

36 00:04:37.850 --> 00:04:39.590 Frans: No, it is.

37 00:04:41.280 --> 00:04:45.380 Frans: There is a yes, somebody wants to say something

38 00:04:45.380 --> 00:04:49.949 Gabor Szabo: No, no, I just going to turn it off it. It beeps when someone joins

39 00:04:50.150 --> 00:04:51.100 Frans: All right.

40 00:04:53.500 --> 00:04:55.160 Frans: Just a moment.

41 00:05:02.250 --> 00:05:05.009 Frans: I've done this before. Sorry guys.

42 00:05:05.010 --> 00:05:06.980 Gabor Szabo: So is it. A windows

43 00:05:07.418 --> 00:05:10.929 Frans: There we go. No, it's it's a Linux

44 00:05:11.355 --> 00:05:14.759 Gabor Szabo: For me. It's control shift plus you usually

45 00:05:14.760 --> 00:05:16.020 Frans: Yeah, there we go.

46 00:05:16.260 --> 00:05:17.920 Frans: That's slightly better.

47 00:05:17.920 --> 00:05:21.180 Gabor Szabo: A little bit more, a little bit more.

48 00:05:22.180 --> 00:05:25.310 Gabor Szabo: Yeah, more, more.

49 00:05:25.310 --> 00:05:26.210 Gabor Szabo: One more sure

50 00:05:27.545 --> 00:05:28.360 Frans: Wow!

51 00:05:29.330 --> 00:05:38.159 Gabor Szabo: Yeah, okay, thanks. That's now. No, at least I can see. I don't know if anyone else still needs larger. Please let us know. For me. It's it's fine

52 00:05:38.920 --> 00:05:46.420 Frans: Okay, good stuff. So basically, let's go. Let's start at the beginning.

53 00:05:46.770 --> 00:05:57.899 Frans: So the 1st thing I started playing with is complex numbers, and the idea is to write A. What in C would be a template class

54 00:06:00.670 --> 00:06:24.770 Frans: to write the equivalent in rust, and to actually have limiting it by means of traits. Okay, so sorry. Let me just take a step back here. The whole idea that I started out with as well is that I wanted to write something. One of the main ideas is that it's completely safe code.

55 00:06:24.820 --> 00:06:35.120 Frans: So I don't call into any under the covers, call into any unsafe libraries, any C or C plus plus libraries.

56 00:06:35.360 --> 00:06:50.489 Frans: Of course, that comes with a performance penalty because you gain quite a lot by. For example, if to do your matrix, arithmetic or matrix manipulation. To do that with

57 00:06:50.630 --> 00:06:56.999 Frans: pointer arithmetic is is generally much faster, but

58 00:06:57.150 --> 00:07:14.019 Frans: I try. I stayed away from it on purpose. So this is all safe for us. Code number one. And also I. Then obviously the closest I could come in terms of performance is by using iterators extensively.

59 00:07:17.140 --> 00:07:25.969 Frans: So, okay, having said that, I started out with the basic ideas of a generic complex number class.

60 00:07:26.310 --> 00:07:37.120 Frans: and there are there are libraries out here that out there that do it, and probably do it much better. So I've got no claim that I'm doing wonderful stuff.

61 00:07:37.540 --> 00:07:43.790 Frans: and as you can see, this will look quite a bit outstanding. But okay, sorry. Let me just go to the top.

62 00:07:44.337 --> 00:07:52.080 Frans: So what I started up is just a basic structural and imaginary, with a type of generic type T.

63 00:07:52.420 --> 00:08:03.800 Frans: And because I wanted to make this compliant with num traits float and integer actually specifically

64 00:08:05.580 --> 00:08:12.919 Frans: I had to define all the traits now, some of them I haven't completed yet, because I didn't

65 00:08:13.530 --> 00:08:21.930 Frans: use the so if we go down here you will see there's some to do's in. There.

66 00:08:22.470 --> 00:08:23.499 Frans: there we go.

67 00:08:25.446 --> 00:08:26.940 Frans: Which is

68 00:08:27.110 --> 00:08:36.119 Frans: probably needs to be fleshed out at some point. So again, just reminding you that this is purely a fun project for me.

69 00:08:36.270 --> 00:08:54.100 Frans: I'm not beholden to anyone to have a finished, polished product. Of course I would like to move to that point, but hey? It's all dependent on when I have time or not. So that's my last excuse I'm going to make

70 00:08:54.480 --> 00:09:03.099 Frans: from us this evening. Okay, so complex numbers, not a big thing. There are things out there pretty much

71 00:09:04.980 --> 00:09:12.970 Frans: And I mean, I'm not going to dwell on this too too much. This is, you can imagine, this is very basic kind of coding.

72 00:09:13.370 --> 00:09:20.389 Frans: right? So, of course, that the aim of that was to start moving into matrices.

73 00:09:20.690 --> 00:09:23.740 Frans: So then

74 00:09:26.980 --> 00:09:34.670 Frans: I start. Okay, sorry. I just want to get you the matrix declaration apologies for this scrolling around.

75 00:09:34.890 --> 00:09:36.490 Frans: Oh, boom!

76 00:09:39.800 --> 00:09:48.610 Frans: So what I decided on in terms of looking towards the future

77 00:09:48.840 --> 00:09:53.970 Frans: to store the all the data in a flat vector.

78 00:09:54.490 --> 00:10:04.109 Frans: generic vector and to make it row dominant. So what that means is that if you if you look at a matrix, and

79 00:10:04.240 --> 00:10:11.780 Frans: you look at the 1st row that would be the first.st So say you've got a a

80 00:10:14.170 --> 00:10:17.920 Frans: in rows. Sorry in columns. So the 1st

81 00:10:18.150 --> 00:10:33.629 Frans: N entries in the vector is the 1st row and then the second N entries that follow onto that is the second row, so I don't know if that creates a easy visualization. But that's for those that don't.

82 00:10:34.240 --> 00:10:36.849 Frans: I haven't heard about road dominance, anyway.

83 00:10:37.090 --> 00:10:50.160 Frans: So and that was sort of then it started getting interesting. So the normal things like adding a matrix subtracting a matrix, extensive use of of just

84 00:10:50.380 --> 00:10:54.589 Frans: iterator and all the the goodies that it has with it.

85 00:10:58.050 --> 00:11:03.670 Frans: So that was pretty so interesting, but pretty straightforward.

86 00:11:03.830 --> 00:11:11.610 Frans: And then I added, stuff like, get the diagonal as a vector, etc, that kind of thing and getting a skew diagonal.

87 00:11:11.920 --> 00:11:21.890 Frans: Also, I find that I wanted to. If you have a matrix of floats, you want to round them off to some decimal place which is very nice

88 00:11:22.040 --> 00:11:48.269 Frans: for later manipulation. I find I needed upper triangular matrices. So if any of these things, these are just different forms of matrices, so upper triangular is all the elements above. The diagonal is non-zero and the one below are 0 kind of thing, and as that is, and lower triangle is triangular is the opposite.

89 00:11:48.770 --> 00:11:53.205 Frans: And we have the famous identity matrix. So

90 00:11:54.660 --> 00:12:07.240 Frans: if this is so, I I'm assuming some level of linear algebra background here. Assumption.

91 00:12:08.370 --> 00:12:16.309 Frans: Then oh, checking if it is an identity, that kind of thing. Okay, so that's pretty much

92 00:12:16.410 --> 00:12:24.000 Frans: sort of what you would think would it would have as a standard library then? Now.

93 00:12:24.200 --> 00:12:27.420 Frans: my! Oh, in this transpose.

94 00:12:30.900 --> 00:12:35.089 Frans: of course. Now this raises very interesting

95 00:12:35.640 --> 00:12:50.880 Frans: when you write this because you have to keep in mind that you have a flat vector storing the stuff. So if you have to do a transpose, you have to carefully work with what they call strides.

96 00:12:51.610 --> 00:12:53.380 Frans: In other words,

97 00:12:55.690 --> 00:13:05.180 Frans: it is normally the offset that you would get to an element in a specific row and column in a flat vector, considering a flat, vector.

98 00:13:06.510 --> 00:13:10.689 Frans: we will talk more about strides when we get to tenses.

99 00:13:11.050 --> 00:13:11.810 Frans: Okay.

100 00:13:11.940 --> 00:13:31.359 Frans: so this was sort of sub matrix. And you can see there's some tests here in a way. You know, I wrote a macro for declaring a matrix like that which is pretty straightforward, and then to get the sub matrix sticking to having this inclusive ranges that you can specify

101 00:13:31.430 --> 00:13:43.310 Frans: from this row to that row, and from this column to this this column inclusive, and it'll give you the sub matrix out of this chunk of bigger matrix, anyway. So that's sort of

102 00:13:43.980 --> 00:13:45.730 Frans: what's going on here.

103 00:13:46.890 --> 00:13:52.510 Frans: Of course, this whole process also to keep in mind is that this is me.

104 00:13:53.530 --> 00:13:59.419 Frans: As you work with iterators, more and more it becomes clearer and

105 00:13:59.540 --> 00:14:02.300 Frans: probably less clunky working with it.

106 00:14:02.680 --> 00:14:03.530 Frans: Okay?

107 00:14:06.200 --> 00:14:31.759 Frans: So also doing stuff like inserting a row, inserting a column, etc. Etc. Then, of course, there becomes augmentation as we adding a sub matrix on top as the description is up top here, the top left corner of a larger matrix. So when we when I start writing matrix, how can I say routines? This becomes important.

108 00:14:32.480 --> 00:14:43.590 Frans: determinant over 2 by 2 and then converting a real to a complex matrix. Okay, so now we start seeing why I started with complex. Because I want you to work

109 00:14:43.930 --> 00:14:50.749 Frans: my 1st aim in doing with this, or the 1st sort of goal that I had was working with complex matrices.

110 00:14:51.300 --> 00:15:13.380 Frans: and there was a very specific reason that I wanted to do it, which I'll show later, or just now put it that way. So now with matrices, you have very famous things like Lu decompositions with Gauss elimination. So this was so now it became really interesting. And I mean, I really actually

111 00:15:13.800 --> 00:15:20.900 Frans: love this stuff sadly, I do other things in life as well.

112 00:15:21.230 --> 00:15:28.340 Frans: This a side note. Humorous side note, anyway. So so that was sort of

113 00:15:29.570 --> 00:15:34.759 Frans: this. I think this was my 1st big achievement. Was it lu decomposition?

114 00:15:36.920 --> 00:15:41.400 Frans: With a partial pivot, fascinating stuff.

115 00:15:41.520 --> 00:16:03.260 Frans: So what was also what I really liked about this is I did, applied math degree long ago. But I you know you completely forget things, because if you don't work with it or not completely forget, but it's so far removed, and what was very nice is, I had to go and sort of read up on how these things work, especially

116 00:16:03.400 --> 00:16:22.099 Frans: from a numerical computing point of view, because that is different to a sort of straightforward, academic, theoretical application of matrices. Because, you know, computing isn't exact. So you always have rounding errors, and you always have to work to a certain precision.

117 00:16:22.330 --> 00:16:25.190 Frans: Anyway, that was linear solving.

118 00:16:25.620 --> 00:16:33.020 Frans: Have I got too complex yet? Sorry sorry about that. I just want to go up this.

119 00:16:33.570 --> 00:16:37.899 Frans: And we saw a real square matrix. No, we're still unreal.

120 00:16:38.410 --> 00:16:40.819 Frans: Okay? So at some point.

121 00:16:48.230 --> 00:16:50.729 Frans: sorry, it must be completely boring

122 00:16:51.480 --> 00:16:55.720 Frans: sort of looking at what I did, quite amazed that I wrote it all.

123 00:16:57.770 --> 00:17:05.419 Frans: Okay. So ultimately, the point was what to calculate eigenvalues of a matrix.

124 00:17:06.140 --> 00:17:21.600 Frans: So and here I established then complex matrix specializations, that where your generic item is a complex matrix of

125 00:17:21.829 --> 00:17:26.040 Frans: T, which you know satisfies numb traits.

126 00:17:30.390 --> 00:17:38.150 Frans: So there was just some things here, and then I think the ultimate is where I do.

127 00:17:39.371 --> 00:17:44.489 Frans: There's a random, complex matrix. By the way, kind of things is where I actually

128 00:17:45.960 --> 00:17:48.319 Frans: own a complex conjugate.

129 00:17:49.440 --> 00:17:52.770 Frans: So this is all to do with complex matrices. And

130 00:17:53.680 --> 00:18:01.819 Frans: this was also beautiful to do complex matrix. QR decomposition using householder transforms.

131 00:18:02.160 --> 00:18:08.325 Frans: This was fantastic. So, by the way, all of this has been

132 00:18:09.260 --> 00:18:13.869 Frans: how can I say ratified against Matlab

133 00:18:15.560 --> 00:18:20.830 Frans: because I wanted to make sure that I'm not putting nonsense out there.

134 00:18:28.210 --> 00:18:31.269 Frans: this is QR complex.

135 00:18:32.990 --> 00:18:44.350 Frans: QR decomposition with householder transforms. So this is all used when you're trying to find the eigenvalues of a matrix. I just want to go right down where I actually do the

136 00:18:46.520 --> 00:18:50.909 Frans: that's the household that transform scar, duck, decomposition

137 00:18:56.570 --> 00:18:58.500 Gabor Szabo: Yeah, I have a question. Franz

138 00:18:58.500 --> 00:18:59.380 Frans: Yes.

139 00:18:59.380 --> 00:19:00.393 Gabor Szabo: Do you?

140 00:19:01.680 --> 00:19:07.819 Gabor Szabo: So, besides writing the the crate, did you make any use of it?

141 00:19:07.820 --> 00:19:15.380 Frans: No, no, no. So so the that's for yourself or yeah. So I'm hoping

142 00:19:16.220 --> 00:19:28.349 Frans: to use it at some point. But at the moment this was purely, as I said in the beginning, for myself, as an entertainment, as something fascinating for me to do. And and

143 00:19:28.450 --> 00:19:43.880 Frans: I enjoy mathematics. And I enjoy solving complex software problems. And a lot of this coding is is

144 00:19:44.490 --> 00:19:54.709 Frans: I. Maybe I'm just old and slow. But I found it very involved and and quite a lot of pencil sketches had to be done

145 00:19:55.260 --> 00:19:58.510 Frans: to figure out how to do this.

146 00:19:58.830 --> 00:20:06.440 Gabor Szabo: I mean, I we use generics and all kind of interesting parts of of rust.

147 00:20:06.600 --> 00:20:13.509 Gabor Szabo: Yes. How did you? Did did you implement anything similar in in CC plus earlier

148 00:20:14.060 --> 00:20:15.890 Frans: No, I've either.

149 00:20:15.890 --> 00:20:20.959 Gabor Szabo: How do you compare what the feeling of of writing rush? That's what I'm trying to ask

150 00:20:21.190 --> 00:20:33.960 Frans: Much, much more difficult. And look, I mean, obviously, I've written C plus plus for what 20 years, you know. So and template programming template libraries is is

151 00:20:34.350 --> 00:20:41.179 Frans: is pretty because you have all these these restrictions, these these things.

152 00:20:41.360 --> 00:21:01.450 Frans: you know making. And if you so, for example, if you are doing an eigen eigenvalue decomposition you are using previous QR or Lu decompositions that you've written to actually facilitate that finding that eigenvalue and

153 00:21:01.700 --> 00:21:24.719 Frans: you have to be so. How can I say? Careful to have the right traits from the bottom up? Otherwise you can't, you know, when you get to the top one. You don't satisfy the traits required to to do it. Kind of thing. If if that makes some sort of sense, I just find it very.

154 00:21:25.200 --> 00:21:49.570 Frans: I mean, I appreciate what it's trying to do here in terms of forcing you to be very, very strict. What you can do. And obviously that is the selling point of rust. Well, one of the selling points of rust is the is safety, and and this really forces you to use it in a very specific way.

155 00:21:50.130 --> 00:22:10.590 Frans: So I do appreciate that. But I may. I mean, look, I'm a youngster in rust if you can put it like that. So maybe that's why I find it difficult, but I found it much more involved than than C plus plus. And of course, and I had to learn the whole iterator setup.

156 00:22:10.860 --> 00:22:15.950 Frans: You know what you can do with iterators, what it actually means. And and

157 00:22:16.330 --> 00:22:26.499 Frans: you know, in in c plus plus, you would have just done as I said. Pointer. Arithmetic, you know, on, on dynamic arrays, or something or static arrays doesn't matter, but

158 00:22:26.660 --> 00:22:30.999 Frans: I think it would be pretty much more straightforward.

159 00:22:32.640 --> 00:22:37.470 Frans: So so this? Why, this was challenging for me to be honest, you know

160 00:22:37.710 --> 00:22:43.045 Gabor Szabo: Do you want to go over the the details of one of the functions to see? So we can. We can,

161 00:22:43.300 --> 00:22:47.157 Frans: Well, I'm I'm just trying to get to

162 00:22:47.640 --> 00:22:51.220 Gabor Szabo: For a simple function, and then, maybe later on, a more complex one.

163 00:22:51.630 --> 00:22:52.110 Frans: Okay.

164 00:22:52.110 --> 00:22:54.929 Gabor Szabo: So so we can have a feeling of of a

165 00:22:54.930 --> 00:22:55.630 Frans: Yeah.

166 00:22:55.630 --> 00:22:56.880 Gabor Szabo: How this code looks like

167 00:22:57.360 --> 00:23:01.159 Frans: Mother, okay. So we out there. So I just want to

168 00:23:01.160 --> 00:23:04.340 Gabor Szabo: I suppose I don't know. Difficult

169 00:23:04.340 --> 00:23:08.539 Frans: Okay, yeah, I transpose this shit.

170 00:23:18.680 --> 00:23:25.519 Frans: There we go. Okay, okay, so this is

171 00:23:26.400 --> 00:23:32.560 Frans: so remember, vector matrix is a flat vector

172 00:23:32.830 --> 00:23:40.880 Frans: so basically, what I do is when I come into this function, I just declare a mutable vector

173 00:23:41.050 --> 00:23:51.370 Frans: a generic vector of type T, which is what the original type is, and it's declared with the capacity of the one that I'm entering in. So

174 00:23:53.280 --> 00:24:03.450 Frans: just to go back to something I said previously is that I was learning as well. So there may be some way of doing this in place.

175 00:24:03.640 --> 00:24:16.490 Frans: But this I just declared a new vector, kind of a result vector, which you can see. I later wrap it into the the matrix that I return, if you like.

176 00:24:17.110 --> 00:24:23.100 Frans: So and then so for each row

177 00:24:25.310 --> 00:24:31.320 Frans: index in the number of columns. So we have number of columns. So this is for each item in the row.

178 00:24:37.140 --> 00:24:39.670 Frans: I have to really scratch my brain here.

179 00:24:44.560 --> 00:25:00.700 Frans: Oh, that's right. I use the skip iter to actually skip the actual offset so that I don't want to actually use this example because this doesn't really show using

180 00:25:00.830 --> 00:25:03.370 Frans: skip, and

181 00:25:03.720 --> 00:25:12.029 Frans: the the iterator function skip and step by which I actually use quite a lot. So anyway. But we can continue with this.

182 00:25:12.340 --> 00:25:15.819 Frans: Then we have. We just

183 00:25:16.680 --> 00:25:23.319 Frans: use a skip it iterator to get to the correct one. Because, remember, if you have.

184 00:25:23.570 --> 00:25:30.109 Frans: where is the example? Here, there we go. So we want to transpose that. So that is the row

185 00:25:30.620 --> 00:25:32.929 Gabor Szabo: And we want to make the row

186 00:25:33.070 --> 00:25:39.100 Frans: The 1st column, right? So you've got to go through the 1st row and write the 1st column.

187 00:25:39.540 --> 00:26:08.629 Frans: But the problem being that you're writing it into a row dominant, vector which is what this result vector, is. So you've got to go and say, if I transpose this, you've got 1, 2, 7 going down and 3, 4, 8 going down. Okay, so you have one and 3 being the 1st row now. So one and 3 will be the 1st 2 elements of the new vector

188 00:26:11.640 --> 00:26:13.690 Frans: here that I'm writing.

189 00:26:16.230 --> 00:26:26.350 Frans: So I I. So you can see in the result. Vector sorry I'll be with you. Now, we actually, we actually just build it up, row by row.

190 00:26:28.200 --> 00:26:28.820 Gabor Szabo: Right.

191 00:26:31.090 --> 00:26:32.489 Frans: Yes, go ask a question

192 00:26:32.490 --> 00:26:39.690 Gabor Szabo: No, I was. I was just wondering if if if the transpose is not just taking the

193 00:26:40.250 --> 00:26:44.599 Gabor Szabo: Xy element in the matrix and put it in. Put it in the YX

194 00:26:44.600 --> 00:26:52.729 Frans: Right. Yes, you can. So if you which, if you have a way of accessing the elements XY,

195 00:26:53.000 --> 00:26:56.640 Frans: which I do have up here, but I'm trying to

196 00:26:56.640 --> 00:26:59.800 Gabor Szabo: An array. Right? The whole thing is just one longer

197 00:26:59.800 --> 00:27:06.580 Frans: Well, well, it's it's resembling an array, but it is stored as a flat vector that that

198 00:27:06.580 --> 00:27:07.880 Gabor Szabo: Vector, sorry. Correct.

199 00:27:07.880 --> 00:27:25.889 Frans: Yeah, flat. Vector so the thing is that I can write this by just saying, for each row, for each column, swap, go get element Xy, and make it element. Yx, and I have the accessors.

200 00:27:26.390 --> 00:27:30.819 Frans: I think I've got it. Sorry. Let me just find it up here.

201 00:27:33.410 --> 00:27:35.800 Frans: Where is? Oh, there index.

202 00:27:36.430 --> 00:27:37.559 Frans: So I've got

203 00:27:37.790 --> 00:27:51.299 Frans: index and index mutable, which will give me access to the the actual XY coordinate, if you like, or the row column coordinate, and then just make just using index to set it to

204 00:27:51.470 --> 00:27:53.630 Frans: to Yx, if you like.

205 00:27:54.050 --> 00:27:58.930 Frans: But that means that you are calling this routines many times.

206 00:27:59.260 --> 00:28:01.090 Frans: Okay in a loop.

207 00:28:01.420 --> 00:28:11.079 Frans: So I would rather, for the sake of efficiency and speed. When I look for which I've lost now.

208 00:28:20.070 --> 00:28:41.300 Frans: I would rather do it directly on the vector and pull chunks out of it than actually. So I'm saving a little bit. Okay, not much, I guess. But this to me, is more efficient than just sitting in 2 for loops and and swapping rows and columns around row and column items around.

209 00:28:42.530 --> 00:28:46.300 Frans: I could be wrong, but that was just my thought on this

210 00:28:50.230 --> 00:28:52.450 Frans: sort of happy Gabor

211 00:28:53.320 --> 00:28:58.680 Gabor Szabo: I'm trying to understand. Yeah, the skipper. What? What is that

212 00:29:00.180 --> 00:29:03.020 Frans: This is, I defined it up here.

213 00:29:11.810 --> 00:29:30.510 Frans: So that is just a way of defining an iterator that skips a certain step size through so you could. Instead of using this. And as I said this, I used in the beginning, and later on I use the iterative actual iter functions step by and skip.

214 00:29:30.690 --> 00:29:33.580 Frans: which is, which would do the same thing as this

215 00:29:35.330 --> 00:29:36.120 Gabor Szabo: Okay.

216 00:29:38.630 --> 00:29:45.700 Frans: So what I'm actually saying subtly is that this would probably needs to be rewritten.

217 00:29:48.700 --> 00:30:04.450 Frans: But for now it works okay. Because and it will become clear. Why, I just sort of went on without really being too fussed about this. Okay, so I don't.

218 00:30:04.640 --> 00:30:06.050 Frans: Okay, hang on.

219 00:30:06.450 --> 00:30:10.980 Frans: Let's get some order here, go!

220 00:30:11.350 --> 00:30:12.679 Frans: Where was that again?

221 00:30:13.250 --> 00:30:14.770 Frans: Can't remember. There we go.

222 00:30:15.100 --> 00:30:16.799 Frans: Okay. So

223 00:30:17.570 --> 00:30:28.179 Frans: that's a very easy function, which, as you rightly say, probably needs to be rewritten. I'm just trying to think if there's not something else that is probably better.

224 00:30:29.950 --> 00:30:33.139 Frans: Sub matrix. You see. Yeah.

225 00:30:33.260 --> 00:30:40.280 Frans: okay. So again, the idea is, you want to grab a chunk out of this. Okay, that's not.

226 00:30:40.660 --> 00:30:42.920 Frans: You want to grab

227 00:30:42.920 --> 00:30:43.450 Gabor Szabo: Rectangle.

228 00:30:43.450 --> 00:30:57.590 Frans: From here here. Yeah, you want to grab a little block out of it, and the way you specify it, you say inclusive. I want to from column 3 to column 7, and from Sorry row.

229 00:30:57.720 --> 00:31:06.859 Frans: row, row column. Always work, row column. So row 3, 2, including row 7, column 2. So you can. It's a little slice out of there.

230 00:31:10.720 --> 00:31:14.199 Frans: So basically, we just check that. It's the correct rows.

231 00:31:14.540 --> 00:31:15.530 Frans: Right?

232 00:31:15.690 --> 00:31:19.100 Frans: Iterate. Get an index going enumerate.

233 00:31:19.230 --> 00:31:22.759 Frans: Then we will skip.

234 00:31:26.070 --> 00:31:42.990 Frans: So we want to position ourselves. So if you imagine just visually, if you want to extract a chunk out of here and remember that it's stored row dominant. You want to 1st get to this row, and you can just strip out

235 00:31:43.160 --> 00:31:47.740 Frans: the number of row elements if you like.

236 00:31:47.860 --> 00:31:57.340 Frans: because they would, they would be adjacent in the to each other in the storage. Vector so this is this will be straightforward

237 00:31:57.470 --> 00:31:58.409 Frans: if you like.

238 00:31:58.810 --> 00:32:01.041 Frans: So you would

239 00:32:02.670 --> 00:32:18.170 Frans: remember this all up here before you get to this element here. This all will be in a flat. Vector so it's a row. Then the next row next row. So you've got to skip the number of columns times up to this row.

240 00:32:18.410 --> 00:32:22.830 Frans: and then you have to skip what the index is that you want to extract.

241 00:32:23.210 --> 00:32:26.400 Frans: So you want to skip 3 rows

242 00:32:26.540 --> 00:32:29.400 Frans: times how many columns is in a row.

243 00:32:29.550 --> 00:32:41.559 Frans: so that, and then you want to add on another little piece until you get here. So that positions you here. So I think you can see that exactly what I've done here.

244 00:32:42.140 --> 00:32:46.410 Frans: the problem, not the problem. But something that

245 00:32:46.710 --> 00:32:56.590 Frans: probably could be changed is that I'm using 0 index. Sorry one indexing for use. But

246 00:32:56.690 --> 00:33:00.270 Frans: obviously it starts at 0. It's 0 indexed.

247 00:33:00.520 --> 00:33:05.830 Frans: So that's why I always have these minus one nonsense, and it gets a bit

248 00:33:06.520 --> 00:33:18.489 Frans: tedious. But anyway, Beta estimate the number of columns times the number of rows above the element. And then, plus where the the column is that we want to extract.

249 00:33:20.020 --> 00:33:24.030 Frans: you can see calls. Start is the 1st one here in the range.

250 00:33:24.950 --> 00:33:28.020 Frans: Okay, so is, is that sort of reasonably clear

251 00:33:28.360 --> 00:33:29.700 Gabor Szabo: Yeah, I think so.

252 00:33:30.450 --> 00:33:33.470 Frans: What I'm doing right? So then.

253 00:33:33.470 --> 00:33:36.420 Gabor Szabo: We're using assert to to verify the

254 00:33:37.510 --> 00:33:38.200 Frans: Yes.

255 00:33:38.420 --> 00:33:51.300 Frans: Well, this is just to make sure that I'm not specifying in my rows and columns something that would sit outside. You know that there isn't enough rows for it to sit in here.

256 00:33:51.540 --> 00:33:52.429 Frans: if you like.

257 00:33:54.990 --> 00:34:03.689 Frans: In other words, I'm not. I'm not wanting to extract this submatrix that is larger in some dimension than the matrix. I'm given

258 00:34:04.520 --> 00:34:05.230 Gabor Szabo: Right.

259 00:34:05.800 --> 00:34:08.346 Frans: Alright. So that's all the sort of

260 00:34:09.250 --> 00:34:12.260 Frans: stuff that I this says that I do there.

261 00:34:14.860 --> 00:34:23.259 Frans: So then, the step by jeez, I'm trying to think what I did here.

262 00:34:26.800 --> 00:34:33.600 Frans: I know I extract little vectors, and then I flatten them. Obviously, this is what's happening here.

263 00:34:34.132 --> 00:34:35.098 Frans: Sorry about that.

264 00:34:35.560 --> 00:34:42.690 Frans: Step by. So I get to the right position. Then I start iterating.

265 00:34:51.400 --> 00:34:57.200 Frans: just thinking, why am I not iterating by one stepping by 1 1st of all?

266 00:35:03.860 --> 00:35:09.729 Frans: Oh, well, guys, sorry I should have spent more time prepping it so I can give better answers

267 00:35:11.410 --> 00:35:16.200 Gabor Szabo: It's fun reading code, even if it even if it's yours.

268 00:35:16.730 --> 00:35:23.520 Frans: Yeah, it's it's it's as I said, I haven't spent time on it, and I've been so in deep in

269 00:35:24.050 --> 00:35:29.630 Frans: trying to find a memory leak on a big golang server. And it's

270 00:35:29.810 --> 00:35:33.599 Frans: it's yeah. My mind has just not been on this at all.

271 00:35:35.780 --> 00:35:57.839 Frans: okay, anyway, if there's real interest. We can come back to this at some point later, when I will make time from the beginning of April, I have more time again, so maybe we can make another arrangement. I can look at this so maybe see this as a sort of a high level view to start off with.

272 00:35:57.980 --> 00:36:03.260 Frans: anyway. So the moving on from this.

273 00:36:05.090 --> 00:36:10.300 Frans: which I hadn't really considered in the beginning. But it became obvious

274 00:36:10.560 --> 00:36:30.679 Frans: that if I wanted to something that would be actually useful in terms of machine learning, I would have to move into tensors. So tensors is just a higher dimensional form of a matrix or a higher dimensional form. A matrix is a higher dimensional form of a vector

275 00:36:30.960 --> 00:36:40.019 Frans: and tensor is then a step up from that so generic N dimensions or rank.

276 00:36:43.790 --> 00:36:45.740 Frans: So this is where

277 00:36:46.500 --> 00:36:54.380 Frans: I actually did the last, my last work, and it's also probably the most from a rust perspective, the most mature.

278 00:36:56.310 --> 00:37:04.740 Frans: So again, I declare, a tensor object generic tensor object using a flat data structure.

279 00:37:07.785 --> 00:37:16.550 Frans: I have the shape of the matrix. Okay, now, I just want to actually hold there and and interrupt myself again and say that

280 00:37:17.310 --> 00:37:19.400 Frans: what I actually

281 00:37:19.630 --> 00:37:31.460 Frans: was trying to do, and I actually had to go back and change the names a bit here because I had the right idea. But I had different names for this. I think I had dims here instead of shape.

282 00:37:31.780 --> 00:37:40.189 Frans: But then I've done quite a bit of work in with tensorflow in, in python, etc. And

283 00:37:40.590 --> 00:37:44.839 Frans: and in the array, and numpy sorry.

284 00:37:45.210 --> 00:38:00.589 Frans: So I had the back of my mind. It suddenly came to me. I want to write something in rust that somebody with a python machining background would feel comfortable in well, reasonably comfortable in using.

285 00:38:00.720 --> 00:38:05.880 Frans: I don't know if that's a pipe dream. But that's sort of where I was going with this.

286 00:38:06.020 --> 00:38:08.569 Frans: So that's why I changed this to shape

287 00:38:09.390 --> 00:38:13.459 Frans: and strides I had from the beginning. So

288 00:38:14.780 --> 00:38:30.030 Frans: let's the go. So again, I'm sitting with row dominance. But whereas previously in a matrix, you have a row, followed by a row, followed by a row. You now have a more complex setup, where you can have

289 00:38:30.540 --> 00:38:35.619 Frans: in dimensions nonspecific. In other words.

290 00:38:36.060 --> 00:38:45.810 Frans: you. You can access the the way that you access an element becomes very much more obtuse

291 00:38:46.090 --> 00:38:55.260 Frans: if I can put it like that. And so that's where why, in the beginning, when I establish the struct I calculate strides

292 00:38:55.520 --> 00:39:05.800 Frans: now, strides is a way that you can use to calculate offset in the vector to get to an element

293 00:39:06.030 --> 00:39:14.780 Frans: of a certain coordinate. Given a coordinate, you can use strides to get to that element, I will demonstrate it shortly. How this works.

294 00:39:16.395 --> 00:39:17.370 Frans: So

295 00:39:18.050 --> 00:39:36.500 Frans: that was pretty straightforward, and in the next line comes to exactly what I've been talking about. So if you have an object declared like this with when you declare a new one, it automatically calculates the strides because it has got the dimensions, the shape, if you like.

296 00:39:37.070 --> 00:39:51.790 Frans: So basically, a stride, is the index of a coordinate. And you can see the coordinate you specify as a, vector because it can be of any dimension

297 00:39:52.030 --> 00:40:06.499 Frans: up to say, 1520, 30. Whatever pick a number. So obviously a good way is to present it as a vector you could probably find other ways of doing this. So here I specify, coordinate as a. Vector

298 00:40:06.640 --> 00:40:07.770 Frans: and

299 00:40:07.950 --> 00:40:19.079 Frans: we can. We can look at an example. I see I don't have an example up here. But yeah, we can look an example. So. But more importantly, you can see that I take the data, which is a vector.

300 00:40:19.240 --> 00:40:27.120 Frans: And I stepped through the coordinates that I were given the spectre. I stepped through it.

301 00:40:27.310 --> 00:40:46.150 Frans: and at the same time I'm stepping through the strides because the number of strides. This vector equals the number of coordinates. And I just do accumulated multiplication. So strides are set up that I can actually get exactly to the offset

302 00:40:46.260 --> 00:40:48.999 Frans: in the vector for this coordinate.

303 00:40:51.230 --> 00:41:01.619 Frans: it takes a bit of thinking, maybe to visual right? You can't really visualize because you're starting to work in. You know, you don't have 2 dimensions as in the matrix.

304 00:41:02.020 --> 00:41:10.629 Frans: But this is, if you think about it long enough, it will become obvious. Well, not obvious, but

305 00:41:10.830 --> 00:41:11.990 Frans: what I'm doing.

306 00:41:14.830 --> 00:41:23.189 Frans: So so there's just a mutable setting that you can assign values back.

307 00:41:25.205 --> 00:41:26.690 Frans: Right?

308 00:41:27.000 --> 00:41:29.150 Frans: So here is the sort of

309 00:41:29.410 --> 00:41:36.050 Frans: generic implementation of tensors where you have stuff like.

310 00:41:37.735 --> 00:41:40.570 Frans: Oh, no. Sorry. My apologies, that's not

311 00:41:44.750 --> 00:41:45.927 Frans: yeah. That is

312 00:41:46.850 --> 00:41:58.639 Frans: what am I saying now, here, standard functions. So anyway, this is just what I wrote, because I got tired of. I wanted to display tenses properly.

313 00:41:58.930 --> 00:42:02.689 Frans: in other words, like python would.

314 00:42:05.095 --> 00:42:08.398 Frans: So this is the sort of

315 00:42:09.370 --> 00:42:15.580 Frans: display that I that I wrote formatting it properly.

316 00:42:16.730 --> 00:42:19.170 Frans: We'll get to that in a moment as well.

317 00:42:19.480 --> 00:42:24.209 Frans: I'll actually write. We can do a real time example of of using this.

318 00:42:25.200 --> 00:42:31.139 Frans: I'm much more comfortable talking about tenses, because it's the last thing I did. So it's probably more recent in my mind.

319 00:42:31.980 --> 00:42:44.889 Frans: recent being a month and a bit ago. Okay, so these are the general functions new declaring it. So you specify a shape, you specify basically all the dimensions in the vector and then you give it the data. Vector

320 00:42:45.840 --> 00:42:54.400 Frans: so the data vector is flat, but the shape gives it its tensor characteristics if you like.

321 00:42:55.330 --> 00:43:12.430 Frans: So you can see when you declare new, you, I can easily calculate the strides, because I have the dimensions and the strides are simply just an accumulated multiplication of

322 00:43:16.820 --> 00:43:22.610 Frans: for each one. You calculate one less, I think.

323 00:43:27.770 --> 00:43:31.860 Frans: and you put it into the strides. So this is what I'm doing here.

324 00:43:32.070 --> 00:43:36.640 Frans: Yeah. So I'm starting at one where index is one.

325 00:43:36.840 --> 00:43:41.920 Frans: So this the zeroth stride is skipping. 0.

326 00:43:43.750 --> 00:43:47.540 Frans: Sorry one. Yeah. Started one skip one

327 00:43:49.450 --> 00:43:54.700 Frans: and then accumulate everyone sort of familiar with this syntax.

328 00:43:54.840 --> 00:43:57.849 Frans: the fold, the initial value, and the closure.

329 00:44:01.400 --> 00:44:04.499 Frans: What I do find very.

330 00:44:05.570 --> 00:44:14.409 Frans: I don't want to use the word annoying, but in a way it is is this sort of dereferencing

331 00:44:14.820 --> 00:44:17.629 Frans: and and and cloning

332 00:44:19.590 --> 00:44:37.580 Frans: And again. I know that's that's the that's the rust. Safety guarantees that things, you know will disappear when they need to disappear or go out of scope. But still writing the code, for it can sometimes

333 00:44:37.710 --> 00:44:42.070 Frans: get very, very challenging, I find.

334 00:44:43.925 --> 00:44:44.600 Frans: Anyway.

335 00:44:44.600 --> 00:44:45.260 Gabor Szabo: Awesome.

336 00:44:45.582 --> 00:44:46.870 Frans: Sorry. That's my dog.

337 00:44:47.640 --> 00:44:48.150 Gabor Szabo: No problem.

338 00:44:48.470 --> 00:44:57.150 Frans: Getting excited there, anyway. So this is just setting up the new new tensor. And then so you have shape strides and the actual database.

339 00:44:57.400 --> 00:44:58.120 Frans: Yeah.

340 00:45:04.170 --> 00:45:07.480 Frans: You can also. Okay. So

341 00:45:07.780 --> 00:45:11.829 Frans: just now, to sort of add on to the discussion about

342 00:45:12.000 --> 00:45:23.659 Frans: find writing something that would start to be slightly, vaguely, vaguely familiar to python users. So there's a tensor library in python called Tensory.

343 00:45:24.965 --> 00:45:29.320 Frans: I don't know if anybody has looked at. I mean go you you

344 00:45:29.320 --> 00:45:29.760 Gabor Szabo: Good.

345 00:45:29.760 --> 00:45:31.930 Frans: Do some python as well. Yeah.

346 00:45:32.690 --> 00:45:40.680 Frans: so tensely is quite an advanced library in terms of using tenses for numeric computing.

347 00:45:40.940 --> 00:45:58.699 Frans: So it's not not like tensorflow, where you specifically, maybe, you know, writing a neural network, and you're training it, etc. That kind of thing. It's more you can do what they call tensor contraction, which we'll get to in a moment.

348 00:45:58.750 --> 00:46:28.699 Frans: and you can do factorized tensor into more as the sum of more usable tensors or even usable matrices. You can sort of change it and and make it. They're all sort of numerical numerical tricks to to make it easier to work with tensors and to manipulate them, and to understand what you're actually trying to do. So

349 00:46:28.800 --> 00:46:35.730 Frans: having said that, I've never really worked with it directly myself.

350 00:46:40.690 --> 00:46:44.200 Frans: Okay, so we get to subtensor.

351 00:46:44.958 --> 00:46:47.650 Frans: Right? So one of the

352 00:46:51.680 --> 00:46:56.339 Frans: One of the big things that I discovered right in the beginning

353 00:46:56.580 --> 00:47:06.300 Frans: is that because you are in matrices. It's very easy. You are working with 2 dimensions, and there's only 2 dimensions, and that's always 2 dimensions. No problem.

354 00:47:07.120 --> 00:47:10.840 Frans: If you are writing a generic tensor that can be anything.

355 00:47:11.680 --> 00:47:19.669 Frans: Then it almost forces you to start using at nested functions within to do things.

356 00:47:19.880 --> 00:47:23.070 Frans: So this also was like a very

357 00:47:23.190 --> 00:47:28.600 Frans: tricky concept to get used to, because

358 00:47:29.150 --> 00:47:36.559 Frans: you could almost think as a tensor where you are. If you want to get to an element you have to.

359 00:47:36.710 --> 00:47:43.979 Frans: How can I put it visually? You can. You must drill down the dimensions until you get to the actual element.

360 00:47:44.130 --> 00:47:54.729 Frans: So that's sort of very strange may sound very strange. But if you write the code, one starts to understand that's sort of what is happening.

361 00:47:54.820 --> 00:48:14.720 Frans: So, for example, here, if you want to extract, get a subtensor of a tensor. You 1st have to. You have to work on all the dimension levels, and at each one you've got to drill down to the required dimension and extract an element

362 00:48:15.180 --> 00:48:21.509 Frans: that sounds very strange now that I say it out loud. But that's really the thought process that's gone on here

363 00:48:21.880 --> 00:48:27.420 Gabor Szabo: Yeah, after 3 dimensions. It's it's getting a bit hairy.

364 00:48:27.600 --> 00:48:33.549 Frans: Yeah. Well, 3 dimensions you could probably still visualize. Yes, with you know. XYZ

365 00:48:33.700 --> 00:48:39.060 Gabor Szabo: Or ZI don't know what you guys call Z in South Africa. We call it Z.

366 00:48:41.500 --> 00:49:01.749 Frans: Zeros standard stuff, you know to this is, if you just want to. So this is all. What happened is then I started looking at tensely. And I say, what did what does it have? And I want to do the same stuff. So Zeros is just to create

367 00:49:01.910 --> 00:49:24.670 Frans: a tensor of this, these dimensions or shape, if you like, so that's probably shape would be a better thing to put in there, and they all just filled with zeros. These are all filled with ones. These are filled with a certain value. T, and this is filled with a certain value range that starts at T

368 00:49:24.840 --> 00:49:25.930 Frans: and go up.

369 00:49:28.240 --> 00:49:29.130 Frans: Yeah.

370 00:49:29.130 --> 00:49:34.309 Gabor Szabo: Yeah, I think dimensions would would say that like it has 3 dimensions, or 4, or whatever right

371 00:49:34.310 --> 00:49:36.919 Frans: Yeah. Yeah. But it's just it's

372 00:49:36.920 --> 00:49:39.309 Gabor Szabo: Described, actually

373 00:49:39.430 --> 00:49:45.379 Frans: It's it's just that in in python and and tensory and and even, you know, numpy, they use shape.

374 00:49:45.560 --> 00:50:09.049 Frans: So I sort of you know there's if if I wanted to make a product that I sort of can really, commercially market or sell or punt, you know, not even commercially, but in seriousness. I would have to go through this and make it all and standardize it, and and and make it much more. How can I say rigorous?

375 00:50:09.510 --> 00:50:16.890 Frans: That's the one thing. The other thing is, I'm sure that a lot of optimization can be done which I'm

376 00:50:17.070 --> 00:50:30.078 Frans: if in a rust perspective, not I haven't gone down that road at all, and which probably needs to be gone down. So I'm not making any. I mean, I've done no benchmarking against anything else. So

377 00:50:30.730 --> 00:50:37.939 Frans: you know, there's probably there's a lot of work that needs to be done for this to be a robust, rigorous library, for sure.

378 00:50:39.420 --> 00:50:44.680 Gabor Szabo: I mean, we are getting close to the, to the, to the 1 h due to

379 00:50:45.290 --> 00:50:50.820 Frans: Do I am. Oh, I'm rambling on endlessly. My apologies, anyway, so

380 00:50:50.820 --> 00:50:52.819 Gabor Szabo: Yeah, I have to wrap up soon, I guess.

381 00:50:52.820 --> 00:51:04.640 Frans: Yeah, so so random and stuff like that. And I think the biggest and the the most difficult thing that I've done up to date was contracting a tensor.

382 00:51:04.960 --> 00:51:05.930 Frans: and

383 00:51:06.120 --> 00:51:25.789 Frans: that so using Einstein's summation notation, I don't know if anybody's familiar with that. So you have basically 2 tenses. And you basically want to contract a tensor ijkl with Mkni, which means you're taking the 3rd dimension

384 00:51:25.980 --> 00:51:28.730 Frans: and contracting it with the second dimension.

385 00:51:29.170 --> 00:51:49.360 Frans: And you're taking the 1st dimension and of the left hand tensor. And you're contracting with the right hand. And what you get basically contraction, you are shrinking the dimensions you are Melding. If I can use that word, adding these 2

386 00:51:49.760 --> 00:51:56.929 Frans: tensors together, and you will end up with a tensor of dimensions. J.

387 00:51:57.300 --> 00:51:59.120 Frans: LMN.

388 00:51:59.550 --> 00:52:12.779 Frans: Right so, and contraction was extremely difficult until it the penny drops. So yes, okay. So, Einstein, notation is just a way of writing it out understandably that that

389 00:52:12.930 --> 00:52:16.550 Frans: tensor algebraus use.

390 00:52:16.820 --> 00:52:22.980 Frans: But the actual underlying routine is the contraction routine, and that

391 00:52:24.120 --> 00:52:33.350 Frans: once you realize that a tensor you have to drill down through all the dimensions, and at the end you end up with a matrix

392 00:52:34.350 --> 00:52:45.949 Frans: at the bottom of drilling down, and once you have that sort of idea in your head, then it's just a question of rearranging

393 00:52:48.410 --> 00:52:51.100 Frans: finding the the correct

394 00:52:51.430 --> 00:52:58.419 Frans: going through the dimensional drill down to find the correct element in the matrix underneath.

395 00:52:58.870 --> 00:53:14.579 Frans: That doesn't sound very nice. But anyway, that's what it happens, anyway. So so that's basically is is sort of where I'm at. As I said, contraction was the biggest thing. Oh,

396 00:53:15.260 --> 00:53:21.029 Frans: Almost the 1st thing I did with tensors is I wanted to do a creation. Macro

397 00:53:22.050 --> 00:53:26.990 Frans: and I had to resort to.

398 00:53:27.660 --> 00:53:40.330 Frans: This was very interesting. I had to resort to writing a separate crate that contains a what's this tensor? What's this? Macro called again.

399 00:53:41.170 --> 00:53:51.880 Frans: Somebody help me here. It's it's not, you know your normal macros, or you can write it in your in your crate. But this is a specific execution, Macro. Process, Macro, sorry.

400 00:53:52.030 --> 00:53:52.700 Frans: Yeah.

401 00:53:53.470 --> 00:53:59.840 Frans: And that's the 1st time that I had to use a nested function.

402 00:54:00.180 --> 00:54:06.249 Frans: Think, here, here is it here

403 00:54:07.460 --> 00:54:11.730 Frans: flatten array? Yes, I used flatten array.

404 00:54:25.880 --> 00:54:37.260 Frans: It's the 1st time I had to use it. So what I was trying to achieve here, and this is so. If we go back to the tensor library, which uses that macro in that crate

405 00:54:37.550 --> 00:54:41.440 Frans: is that you can establish tenses by doing this.

406 00:54:41.790 --> 00:54:43.620 Frans: And that is fantastic.

407 00:54:44.000 --> 00:54:53.240 Frans: I love that because and your community, I mean, this is a like a 12 dimensional tensor.

408 00:54:53.380 --> 00:54:57.829 Frans: you know, which you can establish like. So this is just a stupid example.

409 00:54:57.990 --> 00:55:22.109 Frans: But you can see, and that establishes the shape of that and the strides of that. And that's the actual day test of the flat. Vector anyway, that's about it. So I would love to. You know, if you guys at any point want to chat more about how I did it, I'm happy to have future interaction

410 00:55:22.610 --> 00:55:30.729 Frans: on a 1 to one or one to in a group session, but only from April onwards, because at the moment things are hectic on my side.

411 00:55:31.150 --> 00:55:33.399 Frans: that's it. That's a wrap for me.

412 00:55:33.400 --> 00:55:38.660 Gabor Szabo: Well, thank you. Thank you. April. Is not that far? It's it's like 2 weeks, right? So

413 00:55:38.930 --> 00:55:51.300 Frans: Yes, no, exactly. But that's why it's a bit tense at the moment, because there's lots of pressure, and and there's a there's a substantial bonus involved. If I sort things out so you can understand

414 00:55:52.591 --> 00:56:12.020 Gabor Szabo: Good. So so thank you very much for your for your presentation. By the way, your your information. I I put the link to the to the git repository in the chat, and that if you'll be under the video as well, you will find that and the link to your. I think your Linkedin page. So people will be able to contact you if if interested.

415 00:56:12.110 --> 00:56:25.790 Gabor Szabo: So thank you very much for your presentation and for everyone who who listened, and for everyone who watched the video, and just remember to like the video and follow the channel. Thank you very much. Bye, bye.

416 00:56:25.790 --> 00:56:28.479 Frans: Thanks. Gabor, thanks, guys. Cheers. Bye-bye.