Steve Downey has been a programmer for more than 30 years. Steve graduated from SUNY Purchase with a BS in Mathematics. A Computer Science degree would have involved two classes before 11:00 am, so was impossible. He has worked at Bloomberg since 2003, and is currently working as an Engineer on the C++ Infrastructure team.
Abstract: The use of the functor and monad patterns in ranges, sender-receiver, optional, and expected has been broadly and widely successful. There are other type classes that C++ can profitably adopt for use in generic programming that have proven to be useful in other languages and ecosystems in the last decade. In particular, I am interested in better support for algorithms over trees, and other data structures, where flattening into a sequence loses too much information. In this talk, I will focus on Foldable, Applicative, and Traversable type classes, as well as Monoid, as it provides capabilities for a number […]
Abstract: Today, it is yet again fashionable to criticize Object-Oriented Programming. However, many of the criticisms are aimed at features and practices that are not particularly OO, or are due to impedence mismatches with value-oriented, functional styles. Takeaway: How and why to apply Object Oriented techniques in C++ today in contemporary styles. Object Orientation dominated software development from the 1980s to the early 2000s because it was demonstrably more successful in practice than other existing paradigms. There was intense bottom-up pressure to adopt OO practices. C++ grew up in this environment. Always a multi-paradigm language, it nonetheless incorporates many features […]
Optionals were first proposed for C++ in 2005. Optional<T>, where T is constrained not to be a reference, was added in 2017. Optionals for lvalue references are on track to be added in C++ 26. What were the concerns that made the process take so long? How were concerns addressed? What did we end up with? And, what remains to be done? This talk will discuss the early history of Optionals, starting with Boost.Optional and “N1878: A Proposal to Add an Utility Class to Represent Optional Objects (Revision 1)”, and what the early concerns were for the reference specialization. “P1175R0: […]
Building sender streams out of senders We're going to build an async stream and queue out of nothing but senders. For purposes of this talk, a stream is an infinite collection where you can only get the head element and the rest of the stream. Along the way, we'll take a look at the last 80 years of computer science, including some current areas of active research. Having a better idea of how senders -- and functions like them -- are grounded in theory gives us a better idea of how they can be used and where to look to […]
C++0x Concepts included a feature called "Concept Maps," which allowed a set of functions, types, and template definitions to be associated with a concept and the map to be specialized for types that meet that concept. This allowed for open extension of a concept. A definition could be provided that allows an algorithm to operate in terms of the API that concept presents, and the map would then define how those operations are implemented for a particular type. This is similar to how typeclasses work in Haskell. The feature was very general, and was lost as part of the Concepts-Lite […]
P2300 `std::execution` has been forwarded from the Standard C++ Committee's Library Evolution Working Group (LEWG) for inclusion in C++26, meaning that it is design complete and that the Working Group intends this to be in C++26. The design has had practical implementation experience in C++, and has a solid basis in theory. The model has also been used in other languages, and many patterns can be carried over. However, in many ways, the proposal is refreshingly minimal. It specifies what is absolutely necessary -- and little more -- to build programs using structured concurrency. However, this does make it difficult […]