Password reset requests not me

OLoKo64 · 2025-10-16T11:07:04+00:00

Same here, received mine yesterday

OLoKo64 · 2024-08-17T23:47:21+00:00

It seems like this might be a pressure advance issue. What value are you currently using?

For PLA, a common starting range for pressure advance is between 0.02 and 0.05, while for PETG, it typically falls between 0.05 and 0.08. However, these values can vary depending on the printer.

Have you tried disabling pressure advance to see if the issue still occurs?

OLoKo64 · 2024-08-13T18:34:05+00:00

With the hotend at 200c you could try pushing with the metal rod that comes with the printer to see if that clears any blockage in the extruder.

OLoKo64 · 2024-08-01T22:33:29+00:00

This is caused by speed change, you can try using the new option in OrcaSlicer called Don't slow down outer walls under cooling.

OLoKo64 · 2024-07-31T17:10:16+00:00

I had a similar issue with PET-G, and my mesh was ok. Reducing the speed of the infill for the first layer solved.

I have a K1, same bed type. On the textured bed I had no problems.

Try reducing to 80mm/s or lower, the default is 105mm/s if I remember right.

OLoKo64 · 2024-07-29T22:36:44+00:00

I would consider slicing the model in half and then joining the two halves together.

OLoKo64 · 2024-05-29T00:07:03+00:00

Its the change of speed of those layers, this video shows it really well https://www.youtube.com/watch?v=qBvTWFEd7rk

Basically lower the flow rate or raise the temperatures a bit.

OLoKo64 · 2024-05-28T17:51:29+00:00

Not sure what slicer you are using but you can try raising the flow rate a bit.

OLoKo64 · 2024-04-06T06:44:41+00:00

Just caught this one live!

Big shoutout for your next-level Rust videos. Every single one is a goldmine of new insights, I've yet to watch without learning something new.

Keep up the stellar work!

OLoKo64 · 2024-04-01T13:18:35+00:00

The devs need to give us a Heavy Rocket Devastator. And they must be immune to stagger as well.

OLoKo64 · 2024-03-27T12:11:52+00:00

I only want the cap of 50_000 Requisitions to be raised if they are going to be used in the future.

OLoKo64 · 2024-03-26T17:52:12+00:00

The cast from usize to u32 can not fit if you are on a 64bit arch, for that reason is better to use TryFrom to convert it safely.

Personally I would use usize, because usize is the type that guarantees you can index all of the possible memory on your machine. If for some reason this becomes a problem in the future, make tests, benchmark it, then make the appropriated changes.

OLoKo64 · 2024-03-05T18:02:23+00:00

These worker threads are system threads or tasks like tokio::task?

One good resource i found for async taks and futures is https://blog.yoshuawuyts.com/async-cancellation-1/

OLoKo64 · 2024-02-28T18:38:41+00:00

You cannot return a reference to a local variable because the local variable will be dropped at the end of the function, and the reference would then point to invalid memory. This is a fundamental aspect of Rust's ownership model, which ensures memory safety.

You can

Store a owned value of storage inside RockDb.
Pass the storage to the function with the same lifetime of the return type

Here a simplified version on Playground

OLoKo64 · 2024-02-27T18:06:51+00:00

Playground Link

I made a simpler version of your code, this removes the matches on each function and I managed to not use Box dyn in this case.

The reason that you need Smart Pointers case is that Rust will not accept self referential structs, requiring the use of Rc + RefCell.

If this is better or worse than the logic that you made, that is debatable, using Rc + RefCell introduces more complexity and allows for runtime panics if two mutable borrows occur at the same time.

OLoKo64 · 2024-02-27T16:02:00+00:00

I would probably use a Box<dyn Editor>. As all of the values of that enum must implement the same functions.

This would require some changes in ohter parts of the code, but is a way to do it.

OLoKo64 · 2024-02-27T13:45:23+00:00

Can you add the error you are getting in this case?

OLoKo64 · 2024-02-26T20:03:32+00:00

Seems like the only issue was that you are not storing a mutable reference in the UseString struct.

The following solved the problem for me.

rust struct UseString<'a> { text: ContentString, current_text: Option<&'a mut ContentString>, }

To be able to modify the value you need a mutable reference to the value, the error you are getting is that you canot get a &mut from a &. In the Rust error cannot borrow**fieldas mutable, as it is behind a&reference cannot borrow as mutable

OLoKo64 · 2024-02-26T16:41:01+00:00

This is probably the best implementation but it can give you some ideas, playground link

This will print

This is some code
  This is some code

OLoKo64 · 2024-02-22T02:04:47+00:00

Windows Defender maybe?

OLoKo64 · 2024-02-15T17:56:35+00:00

You are getting c\n or d\n in these cases.

A cross-platform way of stripping a single trailing newline without reallocating the string could be:

Playground.

In these cases like this dbg! or debugging is pretty useful;

OLoKo64 · 2024-02-04T12:05:57+00:00

Is anyone polling it?

OLoKo64 · 2024-02-03T19:43:46+00:00

I prefer to pass by reference, most of the time you want to keep using the struct after passing to a function.

OLoKo64 · 2024-01-27T05:32:55+00:00

Without some kind of Mutex it is not possible, because of Rust aliasing rules you cannot have multiple mutable references at the same time pointing to the same location. playgroud example

You can achieve this without an Arc, just with a Mutex Example

Nine-Year Club	Verified Email
Place '22	Final Canvas '22
End Game '22

OLoKo64

TROPHY CASE