Folly Alternatives

Posts

• Type trait for "does the default constructor 0 initialize all non-static members"
  reddit.com/r/cpp | 2021-06-28

  Facebook's folly library has a way to do it, sort of: by making the developer add a IsZeroInitializable trait to a type - either by adding a typedef/using statement in that type class's declaration, or specializing IsZeroInitializable<> for their type.

• Best learning resources for an experienced developer in a different language?
  reddit.com/r/cpp | 2021-06-12

  Additionally, some libraries you should probably look at are Abseil, Folly, Boost (Opinion is split between heaven send and scum of the earth on this one.), SFML, and SDL.

• Painless C++ Coroutines
  reddit.com/r/cpp | 2021-06-10

  We try to encourage waiting directly on children to maintain strong structured concurrency. We do have fairly basic static analysis to catch some common lifetime bugs. We have library support in the form of co_invoke to help with lambdas and lifetimes. A lot of when_all use (collectAll in our case) but when_any we have tried to avoid - in part because getting solid cancellation support in folly::coro took a while, and cancellation is vital to make safe use of when_any easy.

• C++20 coroutines seem baffling
  reddit.com/r/cpp | 2021-06-03

  Possibly, but all of that functionality has value. We use it to maintain executor affinity for coroutines, to carry context state for web requests, to allow us to trace dependencies between coroutines and to allow us to walk chains of coroutines in gdb with a simple co_bt command.

• "Consuming Interfaces Are Rvalue Reference Qualified" and use-after-move static checks
  reddit.com/r/cpp | 2021-06-02

  In wg21.link/P1054r0, the paper states that "Consuming Interfaces Are Rvalue Reference Qualified." This seems to make sense to me, both making clear to the reader that the object should not be interacted with after calling e.g. get(), and that tools like bugprone-use-after-move would detect code which attempted to further interact with the Future after it's been consumed. Indeed, Facebook Folly Futures rvalue reference qualify consuming member functions.

• Libdill: Structured Concurrency for C (2016)
  news.ycombinator.com | 2021-06-01

  There are plenty of practical solutions to the safe memory reclamation problem in C. The language just doesn't force one on you.

  From epoch-based reclamation (https://github.com/concurrencykit/ck/blob/master/include/ck_..., especially with the multiplexing extension to Fraser's classic scheme), to quiescence schemes (https://liburcu.org/), or hazard pointers (https://github.com/facebook/folly/blob/master/folly/synchron..., or https://pvk.ca/Blog/2020/07/07/flatter-wait-free-hazard-poin...)... or even simple using a type-stable (https://www.usenix.org/legacy/publications/library/proceedin...) memory allocator.

  In my experience, it's easier to write code that is resilient to hiccups in C than in Java. Solving SMR with GC only offers something close to lock-freedom when you can guarantee global GC pauses are short enough... and common techniques to bound pauses, like explicitly managed freelists land you back in the same problem space as C.

• Linked lists be like
  reddit.com/r/ProgrammerHumor | 2021-05-30

  Off the top of my head, I know that both Java and C++'s standard libraries use chaining. In C++ this is why you should use abseil's flat_hash_map, folly's FastMap or other equivalent to avoid this.

• Need Something Sorted? Sleep on It
  news.ycombinator.com | 2021-05-24

  Hashed hierarchical timing wheels is a pretty cool data strucutre to make this efficient. The paper claims it's O(1) to start, stop and maintain timers which is much more efficient than O(log n).

  Given there's n timers and O(1) operations I'm not sure where the O(n log n) fits in here. Possible in the minimum number of ticks?

  http://www.cs.columbia.edu/~nahum/w6998/papers/sosp87-timing...

  Production implementation: https://github.com/facebook/folly/blob/master/folly/io/async...

• FAANG hires C++ Developers?
  reddit.com/r/cpp_questions | 2021-05-23
• std::future and coroutine
  reddit.com/r/cpp_questions | 2021-05-21

  I don't know anything about MSVC but I do know there is no coroutine support library in c++20. You'll need something like folly::coro.

• Kuro - a C++20 coroutine library inspired by asyncio
  reddit.com/r/cpp | 2021-05-10

  I don't seriously expect anyone to use this - I basically just worked on it until I got sick of it and then polished it into a somewhat releasable state. Especially as I've just recently become aware of folly/experimental/coro, which largely seems to be what I've been doing but better. Still, I hope it's of use to some people, even if it's just looking at the code to better understand how to use coroutines in your own code.

• Do I need Flipper?
  reddit.com/r/reactnative | 2021-04-28

  Facebook is working on it https://github.com/facebook/folly/issues/1527#issuecomment-788526038

• Abuse co_await operator for error handling
  reddit.com/r/cpp | 2021-04-27

  It shouldn't be hard to make it work. folly's Expected type supports operator co_await, and I just experimented with moving the promise_type alias out of the class and into a coroutine_traits specialization:

• Experiences with Concurrent Hash Map Libraries
  reddit.com/r/cpp | 2021-04-27

  folly's AtomicHashMap requires knowing the approximate number of elements up-front and the space for erased elements can never be reclaimed. This doesn't work well for our application.

• Why C++ Is Terrifying
  news.ycombinator.com | 2021-04-16

  folly::Function was added for exactly this reason I think https://github.com/facebook/folly/blob/master/folly/docs/Fun...