Folly Alternatives
Similar projects and alternatives to Folly
-
-
-
Scout APM
Scout APM: A developer's best friend. Try free for 14-days. Scout APM uses tracing logic that ties bottlenecks to source code so you know the exact line of code causing performance issues and can get back to building a great product faster.
-
-
-
EASTL
Obsolete repo, please go to: https://github.com/electronicarts/EASTL (by paulhodge)
-
OpenFrameworks
openFrameworks is a community-developed cross platform toolkit for creative coding in C++.
-
-
-
parallel-hashmap
A family of header-only, very fast and memory-friendly hashmap and btree containers.
-
Cinder
Cinder is a community-developed, free and open source library for professional-quality creative coding in C++.
-
-
-
timescale-analytics
Extension for more hyperfunctions, fully compatible with TimescaleDB and PostgreSQL 📈
-
-
terminal
The new Windows Terminal and the original Windows console host, all in the same place!
-
CppCoreGuidelines
The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++
-
tokio
A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ...
-
learnxinyminutes-docs
Code documentation written as code! How novel and totally my idea!
-
-
-
Reviews and mentions
-
My professor is telling us to NEVER use vectors.
Facebook's folly library, for example, has a fbvector type that is a vector that can do that, for types it knows it can do so for. It can also initialize using memset() for types that are zero-initializable.
-
C++ Coroutines Do Not Spark Joy
I think C++ coroutines is best understood not as something you'd use directly, but as plumbing that makes existing async libraries interoperable and easier to use.
For example, Facebook's Folly has been updated to use coroutines and is being widely adopted at FB:
https://github.com/facebook/folly/tree/main/folly/experiment...
-
concurrent-resource - non-intrusive thread safety for non-thread safe types
Check out Facebook's folly::Synchronized.
-
What do computer science students learn that electrical/computer engineering students don't?
Finally, the commercial software systems at places like Microsoft or Google are much, much bigger than what shows up in most EE context, so the programming can be fairly different in order to deal with systems that are not possible for one person to understand one subsystem. If you want to get a taste, Chrome is largely open source. For something related, but a bit different, Facebook has open-sourced their core set of C++ components as well as a library for template metaprogramming in C++.
-
How percentile approximation works (and why it's more useful than averages)
Facebook seems to have an even better performance implementation using sqrt. Might make sense to port that over to Rust. https://github.com/facebook/folly/blob/master/folly/stats/TD...
- Small: inline vectors, sets/maps, utf8 strings, ...
-
A C++ locking wrapper
As another comparison point, folly's Synchronized class takes a similar approach of requiring explicit lock operations. You call .lock (or rlock/wlock for a shared mutex) and get a locked pointer back that you can operate on.
Very powerful pattern. See also folly::Synchronized. Rust's Mutex API also looks like this.
-
Type trait for "does the default constructor 0 initialize all non-static members"
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?
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
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
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
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)
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
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.
Stats
facebook/folly is an open source project licensed under Apache License 2.0 which is an OSI approved license.
Popular Comparisons
Are you hiring? Post a new remote job listing for free.