• 0 Posts
  • 43 Comments
Joined 1 year ago
cake
Cake day: July 24th, 2023

help-circle





  • I was a bit apprehensive because rust has like a gazillion different function types but here it seems to work like just any other language with a HM type system.

    The fn(T)->R syntax works for functions without associated data, it discards details of the implementation and works like function pointers in C. This allows them to be copy and 'static.

    The other function types can have data with them and have more type information at compile time which allows them to be inlined.
    These functions each have their own unwritable type that implements the function traits (Fn(T)->R, FnMut(T)->R and FnOnce(T)->R) depending on their enclosed data.

    I hope I remembered everything right from this video by Jon Gjengset.





  • Short answer:
    It gave us compiler explorer, now that it has served its purpose we should stop doing it.

    Long answer:

    Why does hft even exist?

    Hft can exist because most stock markets react to requests as fast as possible and have no noticable fees for certain use cases. This means algorithms that do simple trades like if goggle goes up, buy other tech companies or buy any stock that goes up in europe on the NY market can make small profits if they are faster than everyone else.

    Does it have any value?

    There is one exchange that imposes a delay on every request, effectively inhibiting hft, and its opening actually improved market conditions on all exchanges. This implies it has negative value.
    They also spend millions on hardware, tools and developers to skim small sums of many transaction on the stock market. They are effectively a (very inefficient) tax on the stock market that goes to improving C++ compilers and funding hardware startups.






  • The new version seems to fix that since your comment was written, but it will stil panics if less than 2 samples are provided, unless the crate it wraps panics at an earlier point.

    let peak = buf
                .iter()
                .copied()
                .enumerate()
                .take(self.sample_count / 2)
                .max_by_key(|(_, s)| (s.abs() * 1000.0) as u32)
                .expect("to have at least 1 sample");
    





  • Keyword reserving is always exciting.
    In this case it’s gen, which allows iterators build on the state machines currently powering async.

    Here is a contrived use case from me.
    It’s not as groundbreaking as async but it’s a convenience. And hey, you could write futures without the async/await keywords, but it’s easier with them