Hello,

I was playing around with rust and wondered if I could use const generics for toggling debug code on and off to avoid any runtime cost while still being able to toggle the DEBUG flag during runtime. I came up with a nifty solution that requires a single dynamic dispatch which many programs have anyways. It works by rewriting the vtable. It's a zero cost bool!

Is this technique worth it?

Probably not.

It's funny though.

Repo: https://github.com/raldone01/runtime_const_generics_rs/tree/v1.0.0

Full source code below:

```rust use std::mem::transmute; use std::sync::atomic::AtomicU32; use std::sync::atomic::Ordering;

use replace_with::replace_with_or_abort;

trait GameObject { fn run(&mut self); fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject; }

trait GameObjectBoxExt { fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject>; }

impl GameObjectBoxExt for dyn GameObject { fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject> { unsafe { let selv = Box::into_raw(self); let selv = (&mut *selv).set_debug(flag); return Box::from_raw(selv); } } }

static ID_CNT: AtomicU32 = AtomicU32::new(0);

struct Node3D<const DEBUG: bool = false> { id: u32, cnt: u32, }

impl Node3D { const TYPE_NAME: &str = "Node3D"; fn new() -> Self { let id = ID_CNT.fetch_add(1, Ordering::Relaxed); let selv = Self { id, cnt: 0 }; return selv; } }

impl<const DEBUG: bool> GameObject for Node3D<DEBUG> { fn run(&mut self) { println!("Hello {} from {}@{}!", self.cnt, Node3D::TYPE_NAME, self.id); if DEBUG { println!("Debug {} from {}@{}!", self.cnt, Node3D::TYPE_NAME, self.id); } self.cnt += 1; }

fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject { unsafe { match flag { true => transmute::<, &mut Node3D<true>>(self) as &mut dyn GameObject, false => transmute::<, &mut Node3D<false>>(self) as &mut dyn GameObject, } } } }

struct Node2D<const DEBUG: bool = false> { id: u32, cnt: u32, }

impl Node2D { const TYPE_NAME: &str = "Node2D"; fn new() -> Self { let id = ID_CNT.fetch_add(1, Ordering::Relaxed); let selv = Self { id, cnt: 0 }; return selv; } }

impl<const DEBUG: bool> GameObject for Node2D<DEBUG> { fn run(&mut self) { println!("Hello {} from {}@{}!", self.cnt, Node2D::TYPE_NAME, self.id); if DEBUG { println!("Debug {} from {}@{}!", self.cnt, Node2D::TYPE_NAME, self.id); } self.cnt += 1; }

fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject { unsafe { match flag { true => transmute::<, &mut Node2D<true>>(self) as &mut dyn GameObject, false => transmute::<, &mut Node2D<false>>(self) as &mut dyn GameObject, } } } }

fn main() { let mut objects = Vec::new(); for _ in 0..10 { objects.push(Box::new(Node3D::new()) as Box<dyn GameObject>); objects.push(Box::new(Node2D::new()) as Box<dyn GameObject>); }

for o in 0..3 { for (i, object) in objects.iter_mut().enumerate() { let debug = (o + i) % 2 == 0; replace_with_or_abort(object, |object| object.set_debug(debug)); object.run(); } } } ```

Note:

If anyone gets the following to work without unsafe, maybe by using the replace_with crate I would be very happy: rust impl GameObjectBoxExt for dyn GameObject { fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject> { unsafe { let selv = Box::into_raw(self); let selv = (&mut *selv).set_debug(flag); return Box::from_raw(selv); } }

I am curious to hear your thoughts.

Python allows programmers to pass additional arguments to functions via comments. Now armed with this knowledge head out and spread it to all code bases.

Feel free to use the code I wrote in your projects.

Link to the source code: https://github.com/raldone01/python_lessons_py/blob/v2.0.0/lesson_0_comments.ipynb

Image transcription:

```python

First we have to import comment_arguments from arglib

Sadly arglib is not yet a standard library.

from arglib import comment_arguments

def add(*args, **kwargs): c_args, c_kwargs = comment_arguments() return sum([int(i) for i in args + c_args])

Go ahead and change the comments.

See how they are used as arguments.

result = add() # 1, 2 print(result)

comment arguments can be combined with normal function arguments

result = add(1, 2) # 3, 4 print(result) ```

---

Output:

3 10

This is version v2.0.0 of the post: https://github.com/raldone01/python_lessons_py/tree/v2.0.0

Note:

v1.0.0 of the post can be found here: https://github.com/raldone01/python_lessons_py/tree/v1.0.0

Choosing lib as the name for my module was a bit devious. I did it because I thought if I am creating something cursed why not go all the way?

Regarding misinformation:

I thought simply posting this in programmer humor was enough. Anyways, the techniques shown here are not yet regarded best practice. Decide carefully if you want to apply the shown concepts in your own code bases.

I have not been able to correlate it to any event in steam. I watched the volume mixer to find out that it was steam. I tried to turn off all notifications but obviously I have missed something. There is no visual cue just this sound in the background.

I appreciate any hints.

I have a static ip (lets say 142.251.208.110).

I own the domain: website.tld

My registrar is godaddy.

If I want to change my nameserver godaddy won't allow me to enter a static ip. It wants a hostname. I observed that many use ns1.website.tld and ns2.website.tld.

I don't understand how this can work because ns1.website.tld would be served by my dns server which is not yet known by others.

Do I need a second domain like domains.tld where I use the registrars dns server for serving ns1.domains.tld which I can then use as the nameserver for website.tld?

I would like to avoid the registrars nameserver and avoid getting a second domain just for dns.

Thank you for your input.

I have two machines running docker. A (powerful) and B (tiny vps).

All my services are hosted at home on machine A. All dns records point to A. I want to point them to B and implement split horizon dns in my local network to still directly access A. Ideally A is no longer reachable from outside without going over B.

How can I forward requests on machine B to A over a tunnel like wireguard without loosing the source ip addresses?

I tried to get this working by creating two wireguard containers. I think I only need iptable rules on the WG container A but I am not sure. I am a bit confused about the iptable rules needed to get wireguard to properly forward the request through the tunnel.

What are your solutions for such a setup? Is there a better way to do this? I would also be glad for some keywords/existing solutions.

Additional info:

• Ideally I would like to not leave docker.
• Split horizon dns is no problem.
• I have a static ipv6 and ipv4 on both machines.
• I also have spare ipv6 subnets that I can use for intermediate routing.
• I would like to avoid cloudflare.