Rewrite in rust(🚀)? #3

FedericoSchonborn · 2021-08-13T10:44:04Z

Have you considered rewriting this in rust(🚀)?

mTvare6 · 2021-08-13T11:15:26Z

Can rust print hello world? because its so hard in c and I would switch to rust if we can do that

mTvare6 · 2021-08-15T13:27:33Z

@gek169 how????????????

Blacksuan19 · 2021-08-15T14:36:12Z

@mTvare6 README.rst????

FedericoSchonborn · 2021-08-15T23:49:54Z

Can rust print hello world? because its so hard in c and I would switch to rust if we can do that

Of course, hello world in rust(:rocket:) could even benefit from:

zero:rocket:cost :rocket: abstractions :rocket:
move 🚀 semantics 🚀
guaranteed 🚀 memory 🚀 safety 🚀
threads 🚀 without 🚀 data 🚀 races 🚀
trait:rocket:based :rocket: generics :rocket:
pattern 🚀 matching 🚀
type 🚀 inference 🚀
minimal 🚀 runtime 🚀
efficient 🚀 C(ringe) 🚀 bindings 🚀

mTvare6 · 2021-08-16T03:30:42Z

Can rust print hello world? because its so hard in c and I would switch to rust if we can do that

Of course, hello world in rust(🚀) could even benefit from:

zero🚀cost 🚀 abstractions 🚀

move 🚀 semantics 🚀

guaranteed 🚀 memory 🚀 safety 🚀

threads 🚀 without 🚀 data 🚀 races 🚀

trait🚀based 🚀 generics 🚀

pattern 🚀 matching 🚀

type 🚀 inference 🚀

minimal 🚀 runtime 🚀

efficient 🚀 C(ringe) 🚀 bindings 🚀

cringe and cve binds

mTvare6 · 2021-08-16T06:42:53Z

can we use the move semantics to create a coroutine that magically turns unsafe code to safe using hello world???????

yes, this program does that to convert all c binds to magic rust safety program object file thing which is very safe to run and is blazing fast

SrijithProDev-2612 · 2022-01-25T16:52:03Z

it is easy to print hello world in rust, just enter the following code and run it

fn main{
    println!("Hello World!);
}

pan93412 · 2022-03-25T09:55:15Z

it is easy to print hello world in rust, just enter the following code and run it
fn main{
    println!("Hello World!);
}

you a newbie 👦 are definitely wrong 👎 . we 😎 usually print hello world to rust(🚀) with laser⚡️ and noto🚀 serif:

ayunami2000 · 2022-05-28T05:27:31Z

how has this thread gone on so long?

Because Rust(🚀) is BLAZING 🚀 fast and so is it's community (🚀). This means we stay on top of bugs 🐜, feature ✨ requests, and issues ❌. We don't let bugs 🐜, feature ✨ requests, and issues ❌ go to waste. Though, Rust(🚀) has no issues, so we just stay on top of bugs 🐜 and feature ✨ requests.

ayunami2000 · 2022-05-28T05:29:07Z

That being said, we need a Rust(🚀) interpreter written in Rust(🚀) in order to rewrite this in Rust(🚀).

pan93412 · 2022-05-28T05:42:11Z

That being said, we need a Rust(🚀) interpreter written in Rust(🚀) in order to rewrite this in Rust(🚀).

rust-lang/rust: (slient)

ayunami2000 · 2022-05-28T06:34:27Z

That being said, we need a Rust(🚀) interpreter written in Rust(🚀) in order to rewrite this in Rust(🚀).

rust-lang/rust: (slient)

That is not ❌ written ✍️ in Rust(🚀). It seems to use 🤢 Python 🐍...

neu-ma-tic · 2022-05-28T19:29:37Z

👀

That being said, we need a Rust(🚀) interpreter written in Rust(🚀) in order to rewrite this in Rust(🚀).

rust-lang/rust: (slient)

That is not ❌ written ✍️ in Rust(🚀). It seems to use 🤢 Python 🐍...

Rust(🚀) is blazing 🚀 fast, but the python 🐍 should 💎 be ported 📡 to Rust(🚀) for max 💯 performance ⭐

ayunami2000 · 2022-05-28T21:14:57Z

👀

That being said, we need a Rust(🚀) interpreter written in Rust(🚀) in order to rewrite this in Rust(🚀).

rust-lang/rust: (slient)

That is not ❌ written ✍️ in Rust(🚀). It seems to use 🤢 Python 🐍...

Rust(🚀) is blazing 🚀 fast, but the python 🐍 should 💎 be ported 📡 to Rust(🚀) for max 💯 performance ⭐

https://github.com/RustPython/RustPython (🚀)

alexjpwalker · 2022-09-05T12:19:27Z

it is easy to print hello world in rust, just enter the following code and run it
fn main{
    println!("Hello World!);
}

This code does not compile 👎 due to missing closing double quote 🙁 and thus merely serves as proof of the need for a truly minimal, robust Hello World application with guaranteed memory safety 🚀

ShakalnyKot · 2022-09-25T15:02:21Z

In C writing of "Hello, World" is also easy!

Create .c file with any name, then save to it this:

#include <stdio.h>
int main()
{
    puts("Hello, world!");
    return 0;
}

and then run:
gcc <name>.c -o <name>; ./<name>
(don't forget to install gcc)

ghost · 2022-10-07T10:14:50Z

In C writing of "Hello, World" is also easy!

Create .c file with any name, then save to it this:
#include <stdio.h>
int main()
{
    puts("Hello, world!");
    return 0;
}
and then run: gcc <name>.c -o <name>; ./<name> (don't forget to install gcc)

c++ user detected??!?!?!??! wtf wtf wtf wtf smh

ShakalnyKot · 2022-10-08T06:34:37Z

In C writing of "Hello, World" is also easy!
Create .c file with any name, then save to it this:
#include <stdio.h>
int main()
{
    puts("Hello, world!");
    return 0;
}
and then run: gcc <name>.c -o <name>; ./<name> (don't forget to install gcc)
c++ user detected??!?!?!??! wtf wtf wtf wtf smh

💬

ghost · 2022-10-08T06:41:11Z

In C writing of "Hello, World" is also easy!
Create .c file with any name, then save to it this:
#include <stdio.h>
int main()
{
    puts("Hello, world!");
    return 0;
}
and then run: gcc <name>.c -o <name>; ./<name> (don't forget to install gcc)
c++ user detected??!?!?!??! wtf wtf wtf wtf smh
speech_balloon

иди нахуй

ShakalnyKot · 2022-10-08T06:44:33Z

In C writing of "Hello, World" is also easy!
Create .c file with any name, then save to it this:
#include <stdio.h>
int main()
{
    puts("Hello, world!");
    return 0;
}
and then run: gcc <name>.c -o <name>; ./<name> (don't forget to install gcc)
c++ user detected??!?!?!??! wtf wtf wtf wtf smh
speech_balloon
иди нахуй

C лучший

mTvare6 · 2022-10-08T12:42:04Z

In C writing of "Hello, World" is also easy!

Create .c file with any name, then save to it this:
#include <stdio.h>
int main()
{
    puts("Hello, world!");
    return 0;
}
and then run:
gcc <name>.c -o <name>; ./<name>
(don't forget to install gcc)

I don't think it's as easy as rust version, anyway it seems to segfault on my toaster running arch

ghost · 2022-10-09T07:38:19Z

I don't think it's as easy as rust version, anyway it seems to segfault on my toaster running arch

Not memory safe =|

ShakalnyKot · 2022-10-09T12:14:20Z

In C writing of "Hello, World" is also easy!
Create .c file with any name, then save to it this:
#include <stdio.h>
int main()
{
    puts("Hello, world!");
    return 0;
}
and then run:
gcc <name>.c -o <name>; ./<name>
(don't forget to install gcc)
I don't think it's as easy as rust version, anyway it seems to segfault on my toaster running arch

there are just nothing to cause segfault

joseluisq · 2022-10-13T07:22:18Z

I believe that if you include the right headers then your can make your C code safe and reliable.

That said, below is an industry-standard well-established piece of code to illustrate what I'm saying.

// SAFETY?: You **must** include the right std header down here,
// if you don't have it then go lazy and use "bindgen" to get one.
// Or even better (safer), include a Rust version of it like "rust_stdio.rs" directly,
// the only downside is that you have to export the whole Rust std into a single file.
// But hey! Rust was thought to be a C/C++ **replacement**
// so it **must** integrate like a charm with cringe C code.
// Do you even think to question that?
#include <rust_stdio.h>

int main()
{
    printf("Hello, world!");
    return 0;
}

P.d. Of course, binary size can vary some MB depending on your target. So at that point, you have to blame LLVM or GCC, at your option.

ShakalnyKot · 2022-10-13T10:48:40Z

I believe that if you include the right headers then your can make your C code safe and reliable.

That said, below is an industry-standard well-established piece of code to illustrate what I'm saying.
// SAFETY?: You **must** include the right std header down here,
// if you don't have it then go lazy and use "bindgen" to get one.
// Or even better (safer), include a Rust version of it like "rust_stdio.rs" directly,
// the only downside is that you have to export the whole Rust std into a single file.
// But hey! Rust was thought to be a C/C++ **replacement**
// so it **must** integrate like a charm with cringe C code.
// Do you even think to question that?
#include <rust_stdio.h>

int main()
{
    printf("Hello, world!");
    return 0;
}
P.d. Of course, binary size can vary some MB depending on your target. So at that point, you have to blame LLVM or GCC, at your option.

Ohhhhh... if we care about memory safety, we shouldn't use printf with one arg
Due of printf implementation it can cause memory issules
so, for printing of hello world better use simpler puts
or do:

#include <rust_stdio.h>

int main()
{
    printf("Hello, world!", NULL);
    return 0;
}

TricolorHen061 · 2022-10-14T05:16:52Z

I believe that if you include the right headers then your can make your C code safe and reliable.
That said, below is an industry-standard well-established piece of code to illustrate what I'm saying.
// SAFETY?: You **must** include the right std header down here,
// if you don't have it then go lazy and use "bindgen" to get one.
// Or even better (safer), include a Rust version of it like "rust_stdio.rs" directly,
// the only downside is that you have to export the whole Rust std into a single file.
// But hey! Rust was thought to be a C/C++ **replacement**
// so it **must** integrate like a charm with cringe C code.
// Do you even think to question that?
#include <rust_stdio.h>

int main()
{
    printf("Hello, world!");
    return 0;
}
P.d. Of course, binary size can vary some MB depending on your target. So at that point, you have to blame LLVM or GCC, at your option.
Ohhhhh... if we care about memory safety, we shouldn't use printf with one arg Due of printf implementation it can cause memory issules so, for printing of hello world better use simpler puts or do:
#include <rust_stdio.h>

int main()
{
    printf("Hello, world!", NULL);
    return 0;
}

Yes, but would this code be blazingly fast(🚀)???

ShakalnyKot · 2022-10-14T07:05:35Z

I believe that if you include the right headers then your can make your C code safe and reliable.
That said, below is an industry-standard well-established piece of code to illustrate what I'm saying.
// SAFETY?: You **must** include the right std header down here,
// if you don't have it then go lazy and use "bindgen" to get one.
// Or even better (safer), include a Rust version of it like "rust_stdio.rs" directly,
// the only downside is that you have to export the whole Rust std into a single file.
// But hey! Rust was thought to be a C/C++ **replacement**
// so it **must** integrate like a charm with cringe C code.
// Do you even think to question that?
#include <rust_stdio.h>

int main()
{
    printf("Hello, world!");
    return 0;
}
P.d. Of course, binary size can vary some MB depending on your target. So at that point, you have to blame LLVM or GCC, at your option.
Ohhhhh... if we care about memory safety, we shouldn't use printf with one arg Due of printf implementation it can cause memory issules so, for printing of hello world better use simpler puts or do:
#include <rust_stdio.h>

int main()
{
    printf("Hello, world!", NULL);
    return 0;
}
Yes, but would this code be blazingly fast(rocket)???

Yes

ShakalnyKot · 2022-10-28T10:53:56Z

Let's go to my pseudolanguage

#Import "LangBase";

/* connect to rust runtime */
#Set Exec.Lang = Rust;
#Set Compiler.EnableExtensions = { RustSupport, RustMacros };
#Set Compiler.EnableLangFeatures = { Rust.BorrowCheching, Rust.SafetyExtension };
#Set Compiler.DisableLangFeatures = { SKPseudoLang.OOP };

/* import rust std */
#Import "(Rust):std" => std;
#Set Exec.Entry = (Objectless):Main();

@Lang:Rust
_none Main()
{
  (RustMacros)println(&"Hello to world of madness!");
};

nitreojs · 2022-10-31T12:17:35Z

shakalnykot just dropped a C(ringe)

ShakalnyKot · 2022-11-01T06:14:37Z

shakalnykot just dropped a C(ringe)

It's rusty cringe

2:

Syntax Error - expected end of linker directive expression:
 13 | @Lang:Rust
                ^
               here
Fix: add semicolon:
 13 | @Lang:Rust;

ShakalnyKot · 2022-11-03T00:39:57Z

shakalnykot just dropped a C(ringe)

1. It's rusty cringe

2:

Syntax Error - expected end of linker directive expression:
 13 | @Lang:Rust
                ^
               here
Fix: add semicolon:
 13 | @Lang:Rust;

3. you are cringe

I know. But Rustaceans is more cringe

ghost · 2022-11-23T17:38:18Z

Obviously you haven't tried AbleScript.

/*Hello, world!*/ print;

TruncatedDinoSour · 2022-11-26T19:44:05Z

Obviously you haven't tried HQ9+.

FedericoSchonborn · 2022-11-27T05:35:41Z

Obviously you haven't tried HQ9+.
H

Not to be confused with h:

ShakalnyKot · 2022-11-29T07:56:15Z

Obviously you haven't tried HQ9+.
H
Not to be confused with h:
h

SVM + svmasm
💀

_start:
    spush 'H'
    scall putchar
    sclr
    spush 0
    scall exit

TruncatedDinoSour · 2022-11-29T13:51:10Z

Obviously you haven't tried HQ9+.
H
Not to be confused with h:
h
SVM + svmasm skull
_start:
    spush 'H'
    scall putchar
    sclr
    spush 0
    scall exit

Why doesn't this look like valid asm
Anyway
x86_64 Linux FASM assembly:

format ELF64 executable 3
segment readable executable

define SYS_exit  60
define SYS_write 1

_start:
    mov eax, SYS_write
    mov edi, 1
    mov esi, c
    mov edx, clen
    syscall

    mov eax, SYS_exit
    xor edi, edi
    syscall

segment readable
    c: db "h", 10
    clen = $ - c

ShakalnyKot · 2022-11-30T06:43:24Z

x86_64 Linux GAS assembly:

.section .text
	.global _start
	_start:
		mov $1, %rax
		mov $1, %rdi
		mov $str, %rsi
		mov $2, %rdx
		syscall
		mov $60, %rax
		xor %edi, %edi
		syscall
.section .data
	.global str
	str:
		.byte 'h'
		.byte 10

TruncatedDinoSour · 2022-11-30T10:56:43Z

x86_64 Linux GAS assembly:

.section .text
	.global _start
	_start:
		mov $1, %rax
		mov $1, %rdi
		mov $str, %rsi
		mov $2, %rdx
		syscall
		mov $60, %rax
		xor %edi, %edi
		syscall
.section .data
	.global str
	str:
		.byte 'h'
		.byte 10

x86_64 Linux NASM assembly:

BITS 64

segment .text
global _start

_start:
    mov eax, 1
    mov edi, 1
    mov esi, c
    mov edx, clen
    syscall

    mov eax, 60
    mov edi, 0
    syscall

segment .rodata
    c: db "h", 10
    clen: equ $ - c

ShakalnyKot · 2022-11-30T13:51:01Z

x86_64 Linux GAS assembly:

.section .text
	.global _start
	_start:
		mov $1, %rax
		mov $1, %rdi
		mov $str, %rsi
		mov $2, %rdx
		syscall
		mov $60, %rax
		xor %edi, %edi
		syscall
.section .data
	.global str
	str:
		.byte 'h'
		.byte 10

x86_64 Linux NASM assembly:

BITS 64

segment .text
global _start

_start:
    mov eax, 1
    mov edi, 1
    mov esi, c
    mov edx, clen
    syscall

    mov eax, 60
    mov edi, 0
    syscall

segment .rodata
    c: db "h", 10
    clen: equ $ - c

x86_64 Linux GAS assembly:

.section .text
   .global _start
   _start:
   mov $1, %rax
   mov $1, %rdi
   mov $str, %rsi
   mov $2, %rdx
   syscall
   mov $60, %rax
   xor %edi, %edi
   syscall
.section .data
   .global str
   str:
   	.byte 'h'
   	.byte 10

TruncatedDinoSour · 2022-11-30T15:50:46Z

x86_64 Linux GAS assembly:

.section .text
	.global _start
	_start:
		mov $1, %rax
		mov $1, %rdi
		mov $str, %rsi
		mov $2, %rdx
		syscall
		mov $60, %rax
		xor %edi, %edi
		syscall
.section .data
	.global str
	str:
		.byte 'h'
		.byte 10

x86_64 Linux NASM assembly:

BITS 64

segment .text
global _start

_start:
    mov eax, 1
    mov edi, 1
    mov esi, c
    mov edx, clen
    syscall

    mov eax, 60
    mov edi, 0
    syscall

segment .rodata
    c: db "h", 10
    clen: equ $ - c

x86_64 Linux GAS assembly:

.section .text
   .global _start
   _start:
   mov $1, %rax
   mov $1, %rdi
   mov $str, %rsi
   mov $2, %rdx
   syscall
   mov $60, %rax
   xor %edi, %edi
   syscall
.section .data
   .global str
   str:
   	.byte 'h'
   	.byte 10

you already sent that one

ShakalnyKot · 2022-12-01T11:46:56Z

x86_64 Linux GAS assembly:

.section .text
	.global _start
	_start:
		mov $1, %rax
		mov $1, %rdi
		mov $str, %rsi
		mov $2, %rdx
		syscall
		mov $60, %rax
		xor %edi, %edi
		syscall
.section .data
	.global str
	str:
		.byte 'h'
		.byte 10

x86_64 Linux NASM assembly:

BITS 64

segment .text
global _start

_start:
    mov eax, 1
    mov edi, 1
    mov esi, c
    mov edx, clen
    syscall

    mov eax, 60
    mov edi, 0
    syscall

segment .rodata
    c: db "h", 10
    clen: equ $ - c

x86_64 Linux GAS assembly:

.section .text
   .global _start
   _start:
   mov $1, %rax
   mov $1, %rdi
   mov $str, %rsi
   mov $2, %rdx
   syscall
   mov $60, %rax
   xor %edi, %edi
   syscall
.section .data
   .global str
   str:
   	.byte 'h'
   	.byte 10

you already sent that one

how to install xen hypervisor?

ghost · 2022-12-02T19:18:26Z

how to install xen hypervisor?

https://google.com

TruncatedDinoSour · 2022-12-02T21:28:42Z

how to install xen hypervisor?

https://google.com

https://searx.tiekoetter.com/

ShakalnyKot · 2022-12-04T11:21:12Z

how to install xen hypervisor?

https://google.com

thanks, i already installed on my test stand with devuan

prechelt · 2023-02-21T10:29:31Z

how to install xen hypervisor?

Oh! I was not aware that Xen has already been reimplemented in Rust.
Great!

ajskateboarder · 2023-03-13T19:26:03Z

Rust 🚀 is 🚀🔥🚀🔥 blazingly 🔥🚀🔥 fast 🔥🚀🔥🚀🔥 and 🚀🚀🚀🚀🔥 memory 🚀 efficient 🔥🚀🚀🚀🚀: with no 🚀 runtime 🚀 or 🚀 garbage collector 🔥🚀🚀🔥, it can power 🚀🚀🚀 performance-critical 🚀🔥🚀 services 🚀🔥, run on embedded 🚀 devices 🚀, and easily integrate 🚀🔥 with other languages 🚀. Rust’s 🚀 rich 🚀 type system 🚀 and ownership model 🚀 guarantee 🚀🔥🚀🔥🚀🔥🚀 memory-safety 🔥🚀🔥🚀🔥🚀🔥🚀🔥 and 🚀 thread-safety 🚀 — enabling you to 🚀 eliminate 🚀 many classes of 🚀🚀 bugs 🚀🚀 at 🚀 compile-time 🚀.

UniqueName12345 · 2023-03-14T00:29:11Z

Have you considered rewriting this in rust(🚀)?

Isn't this already in rust lmao

TruncatedDinoSour · 2023-03-14T14:42:05Z

Have you considered rewriting this in rust(🚀)?

Isn't this already in rust lmao

💀💀💀

UniqueName12345 · 2023-04-05T03:36:34Z

Have you considered rewriting this in rust(🚀)?

Isn't this already in rust lmao

💀💀💀

Oh right. forgot rust(🚀) was a different language from rust

UniqueName12345 · 2023-04-05T03:38:35Z

Rewrite in rust(🚀)? #3

Rewrite in rust(🚀)? #3

Comments

FedericoSchonborn commented Aug 13, 2021

mTvare6 commented Aug 13, 2021

mTvare6 commented Aug 15, 2021

Blacksuan19 commented Aug 15, 2021

FedericoSchonborn commented Aug 15, 2021 • edited Loading

mTvare6 commented Aug 16, 2021

mTvare6 commented Aug 16, 2021

SrijithProDev-2612 commented Jan 25, 2022

pan93412 commented Mar 25, 2022

ayunami2000 commented May 28, 2022

ayunami2000 commented May 28, 2022

pan93412 commented May 28, 2022 • edited Loading

ayunami2000 commented May 28, 2022

neu-ma-tic commented May 28, 2022

ayunami2000 commented May 28, 2022

alexjpwalker commented Sep 5, 2022

ShakalnyKot commented Sep 25, 2022

ghost commented Oct 7, 2022

ShakalnyKot commented Oct 8, 2022

ghost commented Oct 8, 2022

ShakalnyKot commented Oct 8, 2022

mTvare6 commented Oct 8, 2022

ghost commented Oct 9, 2022

ShakalnyKot commented Oct 9, 2022

joseluisq commented Oct 13, 2022

ShakalnyKot commented Oct 13, 2022

TricolorHen061 commented Oct 14, 2022

ShakalnyKot commented Oct 14, 2022

ShakalnyKot commented Oct 28, 2022 • edited Loading

nitreojs commented Oct 31, 2022

ShakalnyKot commented Nov 1, 2022

ShakalnyKot commented Nov 3, 2022

ghost commented Nov 23, 2022

TruncatedDinoSour commented Nov 26, 2022

FedericoSchonborn commented Nov 27, 2022

ShakalnyKot commented Nov 29, 2022

TruncatedDinoSour commented Nov 29, 2022

ShakalnyKot commented Nov 30, 2022

TruncatedDinoSour commented Nov 30, 2022

ShakalnyKot commented Nov 30, 2022

TruncatedDinoSour commented Nov 30, 2022

ShakalnyKot commented Dec 1, 2022

ghost commented Dec 2, 2022

TruncatedDinoSour commented Dec 2, 2022

ShakalnyKot commented Dec 4, 2022

prechelt commented Feb 21, 2023

ajskateboarder commented Mar 13, 2023

UniqueName12345 commented Mar 14, 2023 • edited Loading

TruncatedDinoSour commented Mar 14, 2023

UniqueName12345 commented Apr 5, 2023

UniqueName12345 commented Apr 5, 2023 • edited Loading

FedericoSchonborn commented Aug 15, 2021 •

edited

Loading

pan93412 commented May 28, 2022 •

edited

Loading

ShakalnyKot commented Oct 28, 2022 •

edited

Loading

UniqueName12345 commented Mar 14, 2023 •

edited

Loading

UniqueName12345 commented Apr 5, 2023 •

edited

Loading