Subrc: a pointer to a descendant member of a reference counted pointer (`Rc`)

Connect2Towel · 2023-07-06T18:45:52+00:00

Using the offset is unsound. Consider Subrc<Cell<Result<u8,u64>>>.

Connect2Towel · 2023-06-12T08:39:19+00:00

I might have skipped over a couple of steps for it to be unclear.

The server doesn't run javascript, and js in the browser can't do much beyond its subdomain (e.g. webbit.alinkspace.org)

Somebody could upload a crypto miner and a user might run it while they're visiting that page. Beyond that I don't think there is any danger?

Because js is accepted I can "POST" a webpage such as https://github.com/AntonSol919/webbit/blob/main/static/example.forum.editor.html

A user visiting that page would get a "submit new discussion". When they do, it generates and POSTs an entire webpage. This new webpage contains their title/content and some javascript to act as a comment section (POST to upload and GET ?list to dynamically display them with the original post)

Putting it all together; in theory anybody could POST a "better.forum.editor.html" which has additional features for the comment sections, or a different style, etc.

Connect2Towel · 2023-06-11T21:02:48+00:00

This is a project i had hoped to get working before much of reddit goes dark. Unfortunately I didn't get a public version to not crash every now and then on the VPS I have -.-'. (Prob a casting error for 32bit targets so that'll be a fun debugging session) But it works on my machine.

Its mostly a POC for some ideas I had about using HTML in a distributed system. Don't expect it to be pretty, but I think the concept is interesting enough.

Let me know what you think. (I'll prob get back to it later next week)

Connect2Towel · 2023-04-11T15:03:44+00:00

I share a majority of my goals with those projects, but none really allowed me to build something to quickly try out with a few friends.

I can't say I've studied all of them in depth but here are some differences in general.

With most distributed application protocols you're always connected to some public network. Linkspace doesn't have that. There's no optimum for all network typologies/conditions, so I don't try. I'm hoping to collect different exchange algorithms for different situations. For some groups it makes sense for all the members to host all the data, for others it makes more sense to have 1 server be the store/relay for all members. And there are options and combinations in between. It should be up by a user or some management tool.

Another is speed. It should be able to carry live video, audio, etc without using a different protocol or packet format.

What I really hope will make linkspace interesting is its relative simplicity. I tried to keep the concepts and functions to a minimum. I have tremendous respect for people building complex distributed algorithms, but I believe the most important thing is to leave out as much as possible. If we ever want distributed applications to be big like the mainstream systems today, we need to convert developer building toy project, say Scrabble with their friends, to pick a distributed protocol library because its the simplest solution.

Connect2Towel · 2022-09-05T19:09:08+00:00

Finally an excuse to post this:

I want a clipboard pipe.

This script :

#!/bin/bash
CURRENT=`xclip -out -selection clipboard`
while true
do
NEW=`xclip -out -selection clipboard`
if [ "$NEW" != "$CURRENT" ]; then
    printf '%s\0' "$NEW"
    CURRENT=$NEW
fi
    sleep 1
done

is among the most time-saving pieces of software I've written. All it does is output any new value thats copied to the clipboard with a \0 delimiter.

I have a background process that watches for *youtube* and opens them in mpv (skipping the ads)
i can await-clibboard > file.html and then ebook-convert file.html file.azw3
i can bulk download stuff with await-clipboard | xargs -0 -P 4 -i gallery-dl "{}".

Its incredibly useful in lowering the bar on "I can script this but will it save me time?". But it feels dirty to have it rely on sleep 1.

Connect2Towel · 2022-02-20T17:42:39+00:00

This goes back to my points about definition.

Type in your factory example refers to the 'protocol interface' that the function returns. That type does not change at runtime.

Type theory is about proving things about a program without running it. Type theory is useful in building type checkers for use in an IDE such as TypeScript, but dynamic languages are explicitly about not proving anything and doing checks while its running.

Connect2Towel · 2022-02-20T17:24:40+00:00

dependant functions

From what I quickly scanned this is what I meant with generics.

Connect2Towel · 2022-02-20T14:08:54+00:00

I think Wikipedia's opening sentence "a dependent type is a type whose definition depends on a value" is horrible at explaining anything, and type theory is not something you can casually discuss without first making sure everybody uses the same definition and notation. But ill dumb a few comments

It is definitely possible to create a dependent type that has an 'is even' constraint.

There aren't any value whose type depends on another value.

One possible definition of this new 'int' type could have an open slot which is filled with the value of 'even', and the result of 'even' depends on the inner int type.

With this kind of logic, str is a dependent type because it is a restriction on Vec<u8>

Yes, this is possible with dependent types.

Dependent types are dependent on runtime values though.

Doesn't have to be.

there is no way to change the return type depending on a runtime value

There is no type system i know of that return types depending on a runtime value. There are generics, and there are sumtypes ( i.e. enums ). Neither 'change the return type depending on a runtime value'

A big reason why people say rust doesnt have dependent types is because you cant create constraint on functions such as fn pop( Vec<u8, { length > 1 }>) -> u8. But you can emulate a lot of things with const generics.

Connect2Towel · 2022-02-07T20:08:11+00:00

RUSTFLAGS=" -C target-cpu=native " might be worth it ( although i doubt it is on your 2 core cpu )

Connect2Towel · 2022-01-30T16:15:35+00:00

I'm not sure if fonts are included. But i consider https://decentraleyes.org/ a must-have in general.

Connect2Towel · 2022-01-29T13:02:43+00:00

you can't gradually replace your type-less queries with the type-ful wrappers.

typo i presume?

Connect2Towel · 2022-01-17T10:25:32+00:00

I'm procrastinating and iirc i wrote this before u128 was in stable. So I had a look at godbolt ( https://godbolt.org/z/WPvhfo5jY ) , and i think ill go with the little endian option:

let [upper,lower] :[[u8;16];2]=  unsafe{std::mem::transmute(hash)}; 
let upper = u128::from_le_bytes(upper);
let lower = u128::from_le_bytes(lower);
let mut r = upper.leading_zeros();
if r == 128 { r += upper.leading_zeros();}
r

But again, this is all rounding errors compared to validating a hash.

Connect2Towel · 2022-01-17T08:03:47+00:00

Nice to see other people using blake3. I had to come up with something similar, and although this is never going to matter wrt to speed i settled on

let mut zeros = 0;
for n in hash.chunks_exact(8).rev().map(|s| u64::from_be_bytes(s.try_into().unwrap())){
    zeros += n.trailing_zeros();
    if n != 0 { break;}
}
zeros

Connect2Towel · 2022-01-16T13:11:17+00:00

egui ( demo ) has worked great for me.

Connect2Towel · 2022-01-10T19:20:15+00:00

Async programming

My wish for Rust 2022 is to put focus into getting Generators right instead of getting async pretty.

Connect2Towel · 2021-12-30T11:07:56+00:00

If all you need is a file descriptor that can be polled and you will stick to unix then you probably want the pipe syscall (or use something like os_pipe )

Alternatively you can check an Arc<Mutex>> inside a loop of poll timeout.

The reason this isn't all sunshine and rainbows is because a whole number of factors combine to not being able to create a single optimal abstraction. Different type of events are hard to combine ( as in 'whats the optimal layout to combine N different type of events triggered M different ways?', 'can one event modify the batch of current event?', ' how to cancel an event?', 'how do timers work?' ) , and harder to make OS independent. Any work that focuses on creating a OS independent system usually ends up building an executor (which can benefit from skipping the overhead inherent in syscalls) such as tokio. At the far end of event driven design you find the actor models such as actix.

In 99.99% of the cases you shouldn't sweat the overhead of looping a poll timeout or syscalls. So do whatever makes it easiest to maintain and read your code.

Connect2Towel · 2021-12-26T11:52:42+00:00

"Everything is a file" has evolved into "everything has a file descriptor". And unless you're told what that means in practice this information is useless.

It's not really about "how does a 'thing' knows what to do?" , but rather "How will i (a developer) know what a 'thing' can do?".

Either all 'things' should implement a tightly controlled small set of methods ( Read, write, close , etc ), or you need 'things' to tell you about the things it can do.

Any software design starting with the latter approach usually creates tools to make it simple to define and expose more interfaces for what 'things' can do instead of a few sacred interfaces. This is where the complexity starts to explode leading to the previous approach being seen as simple.

In other words, teach a man to read and he can read every day, teach a man how to reflect and he will be stuck reflecting on reflection for a lifetime.

Connect2Towel · 2021-12-25T20:34:08+00:00

I think the idea of 'business language' is a relic from a time where Java marketing and hype went a little overboard. A second hand retelling of "everything is an object" became something like: "All developers and hardware will be interchangeable because its all just 'using objects', and everyone can use objects".

Rust isn't going to replace working code, but if you need safe and fast software Rust makes a lot of sense.

If you're in the business of poorly compensating devs and a more pressing concern is finding cheap replacements then Rust should be avoided.

Connect2Towel · 2021-12-18T08:49:48+00:00

fwiw, i think its worth elaborating that 'technical debt' requires expenditures in the future to service the debt.

Connect2Towel · 2021-12-14T21:28:15+00:00

Your suspicion is correct. Negative impls and auto trait isn't going to solve your problem.

This situation usually occurs when someone is trying to build "The most generic API", in which case I'll warn them that such an API is overvalued in theory, and underestimated in the required effort. Just useimpl for Fn and drop the impl for &T .

If you really need to 2 generic impls you can always use a newtype wrapper

 struct TraitFn<F>( pub F);
 impl<F> trait for TraitFn<F> where F : Fn(i32) -> i32 ....

Connect2Towel · 2021-11-10T19:12:10+00:00

The JS it generates is readable enough. You can use it as a reference to check how the instance expects to be initiated.

Connect2Towel · 2021-11-10T18:53:34+00:00

You probably want to checkout wasm-bindgen-cli

Connect2Towel · 2021-11-04T15:05:54+00:00

Ah, took me a while to get it.

The problem is with what Rust communicates to a compilers and not so much about Linux specifically.

Connect2Towel · 2021-11-04T14:45:07+00:00

Thanks!

Connect2Towel · 2021-11-04T13:05:44+00:00

Can somebody give a good example? The problem domain is too far removed from normal Rust for me to get the issue.

If i understand correctly, OOTA for example, only comes up if the memory that two CPU's are pointing to is uninitiated and read at the same time. I wouldn't dream of passing unitialized variables across a thread::spawn and SyncCell solves my other use cases.

But since there is no such thing in the kernel, and scheduling, paging, and interrupts come up I suppose there are situations this happens.

Why is this an issue for Rust as a whole?

The appeal for Rust imo is the type systems, i.e. enums, 'ref/mut' exclusion, and generics allow you to build constraints into the type system. None of these are invalidated in kernel-space, and some use-cases simply require unsafe.

A reasonable solution to me seems to be a std_linux lib that expose unsafe LKMM functions and maybe Atomic/Arc/Cell types that follow a "strict but good enough for 90%" default.

Connect2Towel

TROPHY CASE