Learn about the software development process at Globalscape, where a company that started with CuteFTP has "grown up" into a very successful public company that builds enterprise class Windows-based Secure File Transfer and Workflow Automation solutions using Modern(ish) C++ on Windows. We tackle delightful challenges of multithreaded high performance file transfer over TCP/IP based networks; cryptography various flavors; authentication and access controls that run the gamut from password hashes to distributed SAML based SSO; and development of modular and extensible platforms delivered to some of the largest enterprises in the world.
Message handling is frequently used in GUI applications to process user interactions reactively. In this presentation, I'll demonstrate how C++ can be used to rapidly develop performant messaging handling libraries using lambdas and type erasure without the need for polymorphic object creation.
Description: This is an informal gathering for conference attendees in the robotics and automation industry to meet and discuss the current state of C++ in this domain. Topics include popular tools, achieving real-time performance, high-level algorithms for perception and autonomy, and low-level systems integration.
Moderators: Jackie Kay and Rita Ciaravino
We will discuss the challenges involved in an solution to the problem of using modern enums as bitfelds. Along the way we'll sneak in a gentle introduction to SFINAE.
Presentation by Jon Kalb, based on an article in Overload magazine by Anthony Williams
Lifetime safety means writing code that, by construction, is guaranteed to eliminate two things: (a) use of null/dangling pointers (including pointerlike things such as references, iterators, views, and ranges), and (b) leaks (including the rare 1% case where we’re tempted to admit the possibility of an ownership cycle or need to support lock-free concurrent data structures).
Last year, my CppCon 2015 talk “Writing Good C++14… By Default” focused on (a), null/dangling, because it's the more difficult and usually more serious problem. I gave an overview of a new approach of using static analysis rules to eliminate use of null and dangling in C++. That work continues and we’re in the process of writing down the formal rules for the approach that I showed last year.
This year, the focus will be on (b), leaks: The talk aims to begin with a set of simple rules, the “5-minute talk” to demonstrate that a handful of rules can be taught broadly to programmers of all levels, and results in code that is clean and free of leak bugs by construction.
But, since we’ll still have 85 minutes left, we can use the time to spelunk through a series of “Appendix” code examples, in which we'll demonstrate "why and how" to apply those rules to a series of increasingly complex/difficult situations, and that are aimed at increasingly advanced and “clever” (note: not always a good thing) programs and programmers. We’ll address questions such as: How should we represent Pimpl types? How should we represent trees – what should the child and parent pointer types be, and (when) should they be unique and when shared? How should we deal with “intra-module” or “encapsulated” cycles when you control all the objects in the cycle, such as all the nodes within a Graph? And what about “inter-module” or “compositional” cycles when you don’t know in advance about all the objects that could be in the cycle, such as when combining libraries written by different people in a way that may or may not respect proper layering (notoriously, using callbacks can violate layering)? The answers focus on cases where we have solid guidance, and then move toward some more experimental approaches for potentially addressing the ~1% of cases that aren’t yet well covered by unique_ptr, shared_ptr, and weak_ptr.