feddit.org

Summary

Special counsel Jack Smith dropped 44 federal charges against Donald Trump, citing DOJ policy that sitting presidents cannot be prosecuted.

The charges, including election interference and classified documents retention, could be refiled after Trump’s presidency.

Critics, including Rep. Dan Goldman and former Capitol officer Aquilino Gonell, decried the move as a miscarriage of justice, asserting it places Trump above the law.

Trump and allies celebrated the decision as a victory, with Vice President-elect JD Vance vowing to prevent similar prosecutions.

Democrats fear Trump will seek political retaliation, deepening national divisions.

Comments

Even for an HOA this is shitty

Polish defence minister says European countries need to increase spending on their own security; drone attack on Kyiv after Kharkiv and Odesa hit. What we know on day 1,007

Comments

Thank god

For the majority of artists, making music is financially unsustainable. According to a census conducted by the Musicians’ Union, nearly half of working musicians in the UK earn less than £14,000 a year from their craft, while a further half have to sustain their careers with other forms of income. It’s easy to imagine that these are the aspiring performers making tunes in their bedrooms and moonlighting as bartenders, but even household names are turning to alternative income streams.

British singer Kate Nash announced on Thursday that she would start posting pictures of her bottom on adult website OnlyFans to raise money for her tour. The Foundations singer has nearly a million monthly listeners on Spotify, and is playing all across the UK, including a sold out gig in London, but says that touring is a loss making exercise.

She started her “Butts 4 Tour Buses” page in order to ensure “good wages and safe means of travel for my band and crew”. Nash would rather you gawk at her gluteus maximus than listen to Foundations on Spotify. "No need to stream my music, I’m good for the 0.003 of a penny per stream thanks," she told her followers on Instagram.

For an independent solo artist to make the UK living wage they would need 9 million streams a year. But most artists need far more as revenue is split between bands, with record labels often taking a hefty cut.

While Spotify can provide a reliable if paltry source of income, touring is only profitable for musicians playing big venues to sold out crowds. A survey conducted by rehearsal space network Pirate Studios found that only 29% of artists make a profit from tours. Rising costs and a flailing economy have exacerbated this, and a government report earlier this year found that artists are facing a “cost-of-touring” crisis, with travel, accommodation and food prices all higher than ever.

...

With her backside hustle, Nash follows in the footsteps of Lily Allen, who started selling pictures of her feet on OnlyFans over summer. She had the idea after seeing that her feet had a perfect five star rating on WikiFeet, a photo-sharing foot fetish website. Subscribers pay £8 a month to access her posts. In October, Allen claimed that shots of her well-pedicured trotters were earning her more money than Spotify streams – and that’s saying something, considering Allen has over 7 million monthly listeners and more than a billion streams on her top three songs.

For an overview of how to use it, check this video:

https://youtu.be/xvlsJ3FqNYU

also check this video, although it's a bit outdated now.

https://youtu.be/sQYUQNozljo

cross-posted from: https://beehaw.org/post/17246413

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:

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:

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.