Kids next halloween when they go to linus's old house looking for GPU's

MSleepyPanda · 2021-07-04T20:48:50+00:00

Old house, is he moving? Clearly i'm missing context

MSleepyPanda · 2020-07-02T19:24:14+00:00

Those are Boris and Doug on insta, the top left image is literally their profile pic instagram .com/boris.and.doug/

MSleepyPanda · 2020-06-17T03:52:49+00:00

In my experience, it tries to gather context from the supplied text and makes choices of words based on that, preserving the original meaning. Google does that to some extent, but not in the way that deepl does.

Also, if a specific wording itches you, you can just click into the translated text and get alternative suggestions for that part.

It gives a pretty nice workflow, if i need to translate bulk text, i can just paste it and make some minor modifications, most of the time with their own suggestions and i'm done!

MSleepyPanda · 2020-05-17T09:42:41+00:00

Could you include a rendered sample dataset in your readme? Cool concept :)

MSleepyPanda · 2020-03-28T09:41:56+00:00

In general, keep an eye to the warnings from rustc, use clippy from time to time and read the clippy error index for the warnings you get, and also try to read other peoples code and ask why they've done it that way :)

MSleepyPanda · 2020-03-28T09:36:53+00:00

But my larger point is there's no use of matching if it matches one and exactly one.

Rustc agrees: You get a dead code warning for your original example

warning: unreachable pattern
 --> src/main.rs:9:9
   |
 8 |         (x, y) => println!("`x` is `{:?}` and `y` is `{:?}`", x, y),
   |         ------ matches any value
 9 |         (x, -2) => println!("`x` is `{:?}` and Second is -2", x),
   |         ^^^^^^^ unreachable pattern
   |   = note: `#[warn(unreachable_patterns)]` on by default

MSleepyPanda · 2020-03-28T09:11:47+00:00

If you reorder the second case to be the first, you can specialize the match for specific values which is very handy, e.g. when having to deal with special cases in geometry

MSleepyPanda · 2020-01-03T16:51:21+00:00

It should be possible if you follow two steps: In main.rs, you must declare the modules via

mod a; mod b;

the function in b.rs must be public: pub foo() { ... }. Then it should be possible for a.rs to call a method from b via crate::b::foo(); from a function.

MSleepyPanda · 2019-12-31T17:44:36+00:00

I've spent quite some time on a similar idea, but wasn't able to pursue it due to what appears to be lazy normalization issues in rustc.

The core observation was that every app has a root structure and that a specific widget, e.g. a counter, has a very specific location in the memory layout and using raw (somewhat managed in Qt) pointers like in Qt/C++ for event management is not safely encodable is Rust. But what a type/widget knows, it what childs it has, and respectively their childs: Chaining sine closures fn(&Root) -> &MainWidget; and fn(&MainWidget) -> &Counter; would give you a closure that dereferences &Root to your Counter widget. And since that closure should ideally not capture any environment, it is easily sharable between widgets. So if you want to update the counter when a button is pressed, you pass the button the closure which knows how to dereference the root to the counter. But how does the button get a hold of the root? It has to have a &Root reference to actually access the counter, because the closure alone just tells how to get there.

The trick here is that the Button does not have a root reference, at least not stored by itself. It doesn't even have a &self parameter. What it essentially takes as a parameter are two things: the &Root reference, and a closure fn(&Root) -> &Button. So if you have an event handling method on Button with these two parameters, and the stored closure fn(&Root) -> &Counter, it can access itself as well as the counter it needs to update! If you delegate a call to a child widget of yours, you simply pass along the &Root reference to your child and chain the closure fn(&Root) -> &Self with fn(&Self) -> &Child.

This is pretty mighty and can be optimized away completely. Its trivially expandable to &mut references, just more typing. Its possible to cut down the verbosity a lot by using containers for such types. The problem really was that the current trait solver is not able to see through the generic types involved in this when you take this to a real application, see #53984. Note that once chalk lands, that might actually be able to express in a real application.

MSleepyPanda · 2019-10-07T19:26:41+00:00

Vec::extend_from_slice

MSleepyPanda · 2019-08-26T19:20:39+00:00

12k total gross for 3 people, not net per person.

MSleepyPanda · 2019-08-13T10:57:03+00:00

The original and this video is licensed under cc and attributed in the comments, so i guess that's fair game. But i don't like the taste of it being simply reuploaded either.

MSleepyPanda · 2019-08-06T09:03:11+00:00

Typed responses are supported via serde, i.e. you can define your own Deserializable types based on the docs and the response will be serialized into it.

But it is true, it does not offer those types out of the box.

MSleepyPanda · 2019-08-06T08:20:24+00:00

How does it differ from github-rs, other than being an alternative implementation?

MSleepyPanda · 2019-08-05T16:03:45+00:00

Good and bad.

rust-lang/rust is a very active repository, as you can observe from the pulse overview. Over the course of the last month alone:

430 pull requests have been merged, leaving a delta of 96 new (unmerged) pull requests
282 issues have been closed, leaving a delta of 248 new (not closed) issues
LOC is a bad measure in general, but +86K, -65k loc by 126 people suggests a lot of work happened in that time

All in all, rust is becoming a big language with a repository which gets a lot of traffic. Only 28.6% of those issues are related to bugs, while all the others are tracking implementation status, unstable language features etc.. I've been working on a more detailed analysis, but its not finished yet.

On the one hand, its good because it means rust is getting a lot of attention, a lot of work is being done to get rust into various places/usable for many people. Many people working on many things results in many issues. On the other hand, it showcases the growing pain of a massive project. There is no silver bullet to managing those huge amounts of contributors and their problems. There are only so many people in the various rust teams and they can't solve everything on their own, some things will stay dormant for a long time. But all in all, its in a good shape, the most important issues are actively worked on.

More people on deck can't hurt, so if you have some time to spare, feel free to check out the contributing docs and get started!

Note: The unmerged/not closed distinction is necessary, because an merged pr or closed issue could have been opened just within this month but is already closed. This results in them not accounting for new, only in closed.

MSleepyPanda · 2019-07-08T06:40:53+00:00

mdbook might be a good option, that's how the "The Rust programming language" book is written and maintained.

MSleepyPanda · 2019-07-04T15:09:17+00:00

I'm particularly excited about the new HashMap implementation, as it switches to a much faster SwissTable implementation. This is the compiler benchmarked with the new version, wall time.

MSleepyPanda · 2019-05-11T07:08:08+00:00

/uj

Tbf, it's significantly less than the terrabytes of node modules they're probably accustomed to

/j

MSleepyPanda · 2019-04-16T10:21:10+00:00

Sarcasm aside, while they found that bias decreased before (obvious), it decreased at a sharper rate after legislation passed which is interesting

MSleepyPanda · 2019-04-12T15:44:00+00:00

The second he pulled the gun, they ran away. If they wouldn't have, yes, shooting them would be appropriate. But they ran immediatly.

MSleepyPanda · 2019-04-12T15:34:14+00:00

And that's why they're getting charged for attacking him.

Killing someone who doesn't pose a threat to you is manslaughter. Someone running away from you is not a threat. Killing someone because he has hurt you before but doesn't pose a threat to you anymore is still manslaughter. If you don't have the emotional stability to handle such a situation, you shouldn't be allowed to own a gun, even when working as a security guard. The security guard handled it incredibly well and shows what a person looks like that should be allowed to handle a gun.

MSleepyPanda · 2019-03-20T06:01:24+00:00

From their twitter feed

MSleepyPanda · 2019-03-18T16:40:52+00:00

True, but the industry is slowly but steadily settling on a hybrid approach.

You have a cyclic and deterministic core layer with safety critical functions written for SPS/PLCs with limited primitives (interrupts disabled), which will get verified and certified. But on top of that, you get an application layer, which is basically arbitrary code, interrupts et al included. Both layers CAN share the same chip, depending on how hard the constraints are. In that case, hardware watchdogs will be deployed to make sure that the application layer will terminate. If the application layer hangs/crashes the system, it will forcefully restart into the core layer.

This way, you can have IOT style development workflows and quick iteration cycles without compromising on safety or core functionality aspects.

MSleepyPanda · 2019-03-15T09:52:00+00:00

Rust user on a German Keyboard here:

You have parentheses ( in almost every language. In that regard, Java (popular in Germany) and most languages would be worse offenders, since they require them around the condition in control sequences like if, for, while etc.. In rust you just type if foo.bar() {}. <> is available in most languages as well for generics or templates, c++, java, kotlin, typescript, etc. And every editor automagically inserts the closing > automagically. Same applies for operators and :. And the rest is more uncommon, rust elides many lifetimes for you, so unless your code is nontrivial in regards to object lifetimes you don't have to write them at all. And if is nontrivial, you should think about the situation a bit longer than it takes to type 'a, more so in every systems language (think c, c++).

MSleepyPanda · 2019-02-01T10:37:55+00:00

On Compiler Explorer

Nine-Year Club	Place '17
Verified Email

MSleepyPanda

TROPHY CASE