CppCon 2016 Sessions (Audio)

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Iterator Haiku: How five iterator categories blossomed into seven, and Sentinels trimmed them back to five again. Recently proposed changes to the ranges TS distill its seven iterator categories back to five without sacrificing any expressive power. Removing operations that are extraneous in the Sentinel world eliminates a potential source of programming errors. — Casey CarterSoftware Engineer II, MicrosoftCasey Carter is longtime user of C++ who recently ended his career in aerospace manufacturing to participate in C++ standardization. After attending a WG21 meeting, his enthusiasm for Concept library design and semantics somehow turned into authorship of the Ranges TS. He is currently pursuing interests in Ranges, world domination, and doughnuts at Microsoft Redmond.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Efficient bit abstractions for the standard library, or how to beat vector＜bool＞ performances by three orders of magnitude.Can you imagine a perfect world? A world of unicorns. A world of double rainbows. A world of candy mountains. A world in which vector＜bool＞ would not even have existed. As the first three aspects are easy to imagine, I will mostly focus on the last one. For about 20 years now, vector＜bool＞ has been regarded as a bad design decision. There is no problem with the functionality provided by a dynamic vector of bits, but specializing vector for boolean data types was not the best idea ever. In this talk, I will present a radically new approach, generalizing existing implementation practices and experimentations, to achieve both genericity and performances for bit manipulation. I will describe how we designed a minimalist set of abstractions to access and manipulate bits and to serve as a common basis for bit oriented data structures, algorithms and arbitrary precision arithmetic. This presentation echoes a standardization work that will hopefully make bit utilities available in a future revision of the C++ standard library.Bit manipulation is used as a fundamental building block of a wide range of applications including arithmetic of big integers, cryptography, hash tables, compression, fast Fourier transforms and bioinformatics. We started this work while investigating... the expansion of the Universe. Cosmological simulations on supercomputers require fast data structures, and in our case bit manipulation was a bottleneck. A common problem with bit abstractions is that they need a double standard: an easy to use interface for users, and a full access to low level instructions and compiler intrinsics to make the most of modern architectures. I will review our approach and give examples on how to use our library. I will also explain how to use bit values, bit references, bit pointers and bit iterators to design algorithms that outperform bit vectors by factors varying between 100 an 3500. I will conclude this talk by discussing how the bit abstraction proposal may affect the future of the standard library and particularly how it will be interfaced with standard algorithms, standard containers, ranges and arbitrary precision arithmetic.— Vincent ReverdyUniversity of Illinois at Urbana-ChampaignAstrophysicistUrbana-Champaign, Illinois AreaVincent has been working as a post-doctoral researcher at the University of Illinois at Urbana-Champaign (USA) since he obtained his PhD at the Paris observatory (France) in november 2014. His main scientific interests are related to cosmology and general relativity. He his particularly interested in the study of relativistic effects at cosmological scales using high performance simulations run on supercomputers. Because these simulations rely on tree data structures, he started investigating ways to optimize them. He now leads a research team working on tree data structures with main applications in simulations, machine learning, and data science. He also participates into the C++ standardization process and regularly submits proposals to improve the C++ language.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—C++ was lacking the reflections feature for a long time. But a new metaprogramming trick was discovered recently: we can get some information about POD structure by probing it's braced initializes. Combining that trick with variadic templates, constexpr functions, implicit conversion operators, SFINAE, decltype and integral constants we can count structure's fields and even deduce type of each field.Now the best part: everything works without any additional markup nor macros typically needed to implement reflections in C++.In this talk I'll explain most of the tricks in detail, starting from a very basic implementation that is only capable of detecting fields count and ending up with a fully functional prototype capable of dealing with nested PODs, const/volatile qualified pointers, pointers-to-pointers and enum members. Highly useful use-cases will be shown a the end of the talk. You may start experimenting right now using the implementation at https://github.com/apolukhin/magic_get.— Antony PolukhinYandexHi, I'm Antony Polukhin, the author of Boost.TypeIndex and Boost.DLL libraries; maintainer of the Boost.LexicalCast, Boost.Any, Boost.Variant and Boost.Conversion libraries. I'm also the author of of the "Boost C++ Application Development Cookbook"—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—One of the motto of C++ is « costless abstractions », a.k.a. you only pay for what you use. To achieve this goal, modern C++ puts a heavy burden on the compiler. But what does the compiler really does when it meets an exception? When it finds a nested lambda? When it encounters a structure that wraps a single scalar?During this talk, we'll go trough a set of innocent C++ sample that involves several data types and algorithms from the standard library, and verify that the costless abstraction principle holds, especially when looking at the difference between several optimization level, eventually digging into specific compiler optimization to understand what happens under the hood.This talk uses Clang++ as the reference compiler, and relies on its LLVM bitcode output to explain how the abstractions are lowered (or completely pruned) at the Intermediate Representation level.— Serge GueltonQuarksLab—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Asynchronous I/O is an essential technology for increasing concurrency without introducing more threads, which carry both overhead and risks. Unfortunately, leveraging async I/O can be disruptive to careful code architecture.This talk focuses not on the mechanics of async I/O, but rather on a library that manages async I/O with code that looks and behaves like traditional sequential code. Boost.Fiber introduces "userland threads," permitting the application coder the benefits of both async I/O and clean layers of abstraction.This talk presents an overview of the library, discusses integration with event-driven frameworks and illustrates several useful patterns.—Nat GoodspeedLinden LabNat Goodspeed first read about C++ shortly after implementing a medium-sized language interpreter in classic C. Almost every C++ feature led to forehead smacking accompanied by muttered remarks about how the language could have solved THIS problem... He has been fascinated (sometimes infuriated) by C++ ever since.When he first encountered Boost libraries, a light shone from the heavens and choirs of angels sang "AAAAAAH..." The idea of writing and maintaining C++ code without Boost has become unthinkable -- even now that some of those libraries have been adopted into the C++ standard.Nat has presented papers on coroutines and fibers to WG21, the ISO C++ committee. He has spoken on these topics at C++ Now conferences.Nat has worked on databases, games and virtual worlds, usually on architecture and infrastructure. He has functioned as Boost evangelist within various organizations.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Want to get started compiling C++ code for the Web? Come to this session to learn how. We'll look at the tools, C++ libraries, and C++ OpenGL and SDL APIs, available to C++ programmers today, and walk through building and running a C++ application in Web browsers using WebAssembly, the new cross-browser standard for compiled code on the Web.We'll also do an deep-dive tour through the entire system, starting from C++ code, through the compilation process to the WebAssembly binary format, and then to native code. We'll look at how to make C++ code interface with Web APIs and JavaScript, how both standalone C++ and hybrid applications are built, how WebAssembly delivers the kinds of performance characteristics C++ code expects while keeping users safe, and how C++ developers can make the most of WebAssembly's optimizations for fast download and startup times to deliver great experiences on the Web.Let's play some games, have some fun, and do some serious C++ on the Web!— Dan GohmanMozillaWebAssembly. asm.js. Emscripten. Itanium C++ ABI V2. SIMD. Undef. AliasAnalysis. Instruction Sets. Control Flow representations. Floating point determinism. Vulkan. NaNs. Did I say WebAssembly?—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—At CppCon 2015 we introduced the Guideline Support Library (GSL): a set of portable vocabulary types for use constructing safe and efficient C++ programs. This talk looks at how the library has evolved in the course of one year. The talk will provide a brief review of the current set of facilities in the library, where it is available, how to build and contribute. Then the talk will look at how the library changed in response to feedback and contributions from the user community, as well as from the ISO C++ Working Group as parts of the library move through the standardization process for inclusion in the C++ standard library. The talk will cover lessons learned about how to optimize key parts of the library - such as the span＜T＞ type - in the compiler, and what had to change in the library implementation to support this. It will present some examples of these optimizations and discuss performance of span＜T＞. Finally, the talk will include a status report on notable places the library is being used and preview what might be next for the GSL.— Neil MacIntoshPrincipal Software Engineer, MicrosoftNeil is the lead for the C++ static analysis frameworks used widely within Microsoft, including PREfix, PREfast, and EspXtension, as well as the /analyze feature of the Microsoft C++ compiler. He is currently focused on making all these tools work better with portable C++14 code rather than nonstandard annotations. He also maintains Microsoft's implementation of the Guideline Support Library (GSL).—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Facebook has open sourced Folly, its core C++ Library and the foundation of all of Facebook's C++ code. Folly builds practical, efficient, and novel components on top of the standard library. Facebook engineer Dave Watson will do a deep dive on the core components, and investigate how they have changed over time. We will compare its design with previous talks and proposals, and highlight insights learned from real-world usage in Facebook's large production codebase.Topics include: * Singletons in a world with fork * Useful ThreadLocals * Pragmatic exceptions * Easy type conversions * Optimizing primitives, such as shared_mutex, vector, and atomic_shared_ptr— David WatsonEngineer, FacebookDave Watson is an infrastructure engineer at Facebook. He has been focused on improving the application server stack, including improvements in RPC, load balancing, memory management, and asynchronous programming. He has contributed to many of Facebook's core services and OSS projects, including HHVM, folly, proxygen, wangle, and mcrouter. Previously he worked at F5 networks on load balancers and network monitoring tools.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—C++ does not yet have complete introspection (reflection), but in many cases it may be easy to complete. We will present an example of what we think is is a general method whenever data specifications may be converted to C++ through a code generator. We have done this for processing financial market data very sensitive to latencies and obtained huge advantages of * Economy of effort * Performance * Reliability * Extensibility over any other option we considered. We will show: * How we converted the specification of market data from an important exchange, CME MDP3, into C++ types and a minimal set of variadic templates that give us full introspection capabilities * The code and the techniques to implement generic introspecting software components, including these concrete examples: * Converting any value that belongs to the specification into string * Testing for whether the value is null in any of the three ways the specification allows encoding of null values * Applying design patterns such as flyweights to traverse the data with zero or minimal performance cost * Subscription mechanismsWe hope these code examples will show how straightforward and maintainable metaprogramming techniques can emulate introspection for truly significant quality gains.Support code at github:https://github.com/thecppzoo/cppcon2016/— Eduardo MadridSoftware Developer, Crabel Capital ManagementEduardo Madrid has over 18 years of C++ experience and works as Software Developer at Crabel Capital Management. The material for this presentation is derivative of work made by him currently running in production at "Crabel" to process CME MDP3 financial data. "Crabel" is a Hedge Fund with activities including automated trading, it has been continuously successful for over two decades, and is among the largest trader of Futures—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—I started writing my own Content Managment System for Meeting C++ last year. One of the goals for this project is to seperate the Qt GUI code from the layer that handles the logic and data storage, written in modern C++ and boost. This presentation will focus on my usage of modern C++ to implement the CMS.Today my CMS has a little bit more then 10k loc, uses boost extensively and has a Qt GUI as the user facing frontend. In this talk I will focus on how boost powers the application and where I had to find my own solutions. I knew that with boostache there is a library for text templates, which later also inspired me to write a generic layer to use JSON for import and data storage in my CMS. The resulting generic_json library is currently a prototype, but a very interesting idea: uniting several json libraries into one interface. This way my own code is not hard wired to a specific JSON library.— Jens WellerMeeting C++C++ EvangelistJens Weller is the organizer and founder of Meeting C++. Doing C++ since 1998, he is an active member of the C++ Community. From being a moderator at c-plusplus.de and organizer of his own C++ User Group since 2011 in Düsseldorf, his roots are in the C++ Community. Today his main work is running the Meeting C++ Platform (conference, website, social media and recruiting). His main role has become being a C++ evengalist, as this he speaks and travels to other conferences and user groups around the world.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, one also needs a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. In this talk we begin by briefly reviewing the basics of physical design. We then present a variety of levelization and Insulation techniques, and apply them in present-day, real-word examples to avoid cyclic, excessive, or otherwise inappropriate dependencies. Along the way, we comment on how to make the best use of what the C++ language has to offer.— John LakosBloomberg LPSoftware Infrastructure ManagerJohn Lakos, author of "Large Scale C++ Software Design.", serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide. He is also an active voting member of the C++ Standards Committee, Library Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science ('97) and an Sc.D. in Electrical Engineering ('89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics ('82) and Computer Science ('81). His next book, entitled "Large-Scale C++, Volume I: Process and Architecture", is anticipated in 2014.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, one also needs a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. In this talk we begin by briefly reviewing the basics of physical design. We then present a variety of levelization and Insulation techniques, and apply them in present-day, real-word examples to avoid cyclic, excessive, or otherwise inappropriate dependencies. Along the way, we comment on how to make the best use of what the C++ language has to offer.— John LakosBloomberg LPSoftware Infrastructure ManagerJohn Lakos, author of "Large Scale C++ Software Design.", serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide. He is also an active voting member of the C++ Standards Committee, Library Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science ('97) and an Sc.D. in Electrical Engineering ('89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics ('82) and Computer Science ('81). His next book, entitled "Large-Scale C++, Volume I: Process and Architecture", is anticipated in 2014.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, one also needs a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. In this talk we begin by briefly reviewing the basics of physical design. We then present a variety of levelization and Insulation techniques, and apply them in present-day, real-word examples to avoid cyclic, excessive, or otherwise inappropriate dependencies. Along the way, we comment on how to make the best use of what the C++ language has to offer.— John LakosBloomberg LPSoftware Infrastructure ManagerJohn Lakos, author of "Large Scale C++ Software Design.", serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide. He is also an active voting member of the C++ Standards Committee, Library Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science ('97) and an Sc.D. in Electrical Engineering ('89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics ('82) and Computer Science ('81). His next book, entitled "Large-Scale C++, Volume I: Process and Architecture", is anticipated in 2014.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—SIMD extensions have been a feature of choice for processor manufacturers for a couple of decades. Designed to exploit data parallelism in applications at the instruction level, these extensions still require a high level of expertise or the use of potentially fragile compiler support or vendor-specific libraries. While a large fraction of their theoretical accelerations can be obtained using such tools, exploiting such hardware becomes tedious as soon as application portability across hardware is required.Accessing such capabilities directly from C++ code could be a major improvements in a lot of use cases. Different take on this has been proposed either by the community or as an actual standard proposal. Solutions include pragma based annotations, standard algorithms policies, full blown compiler support and libraries. In this talk we will present one such solution - the Boost.SIMD library (currently being proposed as such) which takes a library approach to this issues.We will go over the basic notion required to grasp SIMD programming in general. Then, we'll discuss the different existing approaches. We will describe Boost.SIMD API and API design to demonstrate how it solves issues raised by the actual idiomatic way of writting SIMD enabled code. Design issues like standard algorithm integration, memory handling and how to fill the gaps in SIMD instructions sets will be discussed. Finally, we show its performances with respect to a subset of well known benchmarks.— Joel FalcouCTO, NUMSCALEJoel Falcou is NumScale CTO. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems. | | He is also an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d'Informatique in Orsay, France.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—This presentation describes the necessity, utility and usage for a library of safe integer types. These types function in all respects the same way as built-in integers, but guarantee that no integer expression will return an incorrect result. The library can be reviewed at the boost library incubator.— John McFarlaneProgrammerJohn McFarlane has used C++ for twenty years, specializing in simulation, AI and interactivity. He is a contributor to Study Groups 6 and 14 and is involved in standardizing fixed-point arithmetic.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 7, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—This presentation describes the necessity, utility and usage for a library of safe integer types. These types function in all respects the same way as built-in integers, but guarantee that no integer expression will return an incorrect result. The library can be reviewed at the boost library incubator.— Robert RameyRobert Ramey Software DevelopmentProprietorSanta Barbara, CARobert Ramey is a freelance Software Developer living in Santa Barbara, California. (See www.rrsd.com.) His long and varied career spans various aspects of software development including business data processing, product, embedded systems, custom software, and C++ library development. Lately, he has been mostly interested in C++ library design and implementation related to Boost. He is the author and maintainer of the Boost Serialization library and a frequent contributor to the Boost developers list.—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 6, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—While 2014 CppCon talk "C++ in Huge AAA Games" focused on reality for a lot of games developed at Ubisoft Montreal, this talk with focus on what was done to ship Rainbow Six Siege at 60 frames per second. Delivering a game with 5 versus 5 multi-player with heavy procedural environment destruction at 60 FPS was a constant challenge. From memory usage to lock-free solutions, a lot of developed C++ solutions are reusable outside of games. Some interesting analysis tools were also developed to find issues, and their concepts could be reused by any C++ developer caring about performance. — Nicolas FleuryTechnical Architect, Ubisoft MontrealNicolas has 13 years of experience in the video game industry, more years in the software industry in telecoms, in speech recognition and in computer assisted surgery. Technical Architect on Tom Clancy's: Rainbow Six Siege, he is one of the key Architects behind some collaboration initiatives at Ubisoft and was also Technical Architect on games like Prince of Persia. He presented at CppCon 2014 "C++ in Huge AAA Games".—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 6, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Writing correct C++ is hard. Period. Full stop. Even if a small change to a simple 2,000-line program compiles, has tests, and passes the tests, the code might still be broken. When the code spans hundreds of thousands of files across many different projects, making sure your change is safe is orders of magnitude harder. This talk is about all of the things that make that problem manageable for a Facebook engineer to tackle.— Mark IsaacsonFacebookSoftware EngineerMark Isaacson is a Software Engineer at Facebook, where he works on improving the developer experience for all C++ programmers at Facebook. Mark is the author of the tech blog "Modern Maintainable Code" that tries to educate folks about properties of maintainable code and effective program design. Mark has a background in teaching and has been giving tech talks for several years now, most of which can be found on his blog. Website: http://modernmaintainablecode.com—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 6, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—DescriptionModern applications in enterprise software comprise a complex web of streaming data sources and sinks. Data is constantly flowing across the network generated by a disparate set of clients, written in a multitude of programming languages, intended for local and/or remote resources. From the smallest devices in the Internet of Things (IoT) to the largest mainframes or connected subnets in Banking and Finance systems, the core abstraction used at the heart of all of this technology has been the message. However, messaging is an overloaded term with many meanings depending on the connotation and context. But we are going to focus on how C++ and the MQTT protocol can participate in the polyglot programming languages of the modern Enterprise Messaging landscape. Our focus will be on a scalable server-side framework that can provide messaging in any context from an IoT device all the way up to a large Banking mainframe.AbstractIn the context of Enterprise Messaging the MQTT protocol and the design of a C++ MQTT Message Broker provide a perfect mixture of language support and features to build a scalable, extensible, high-quality Enterprise Messaging solution. In order to demonstrate how this is possible I will introduce Enterprise Messaging Systems and enough of the concepts of Enterprise Messaging to be able to create a shared understanding of the role and features needed to implement a basic Message Broker using modern advanced C++ idioms. I will then demonstrate how data integration using a Message Broker, with specific messaging models, can support several message integration use-cases.The talk will focus on demonstrating how C++ fits into the context of Event Driven-Architecture (EDA) at the enterprise-level and how the language's newer idioms allow it to excel at the task. The talk will utilize C++ 14 making extensive use of Template Metaprogramming, multi-threading, asynchronous I/O, correct usage of move semantics and examples of cross-platform networking abstractions. It is geared to the intermediate to advanced developer wanting to learn more about messaging and EDA, MQTT, and extending C++ deeper into the enterprise as a serious language addition to the polyglot movement in enterprise development today.The talk piggy-backs on another MQTT talk about a client-side framework for an IoT project being proposed by Michael Caisse. The two are not dependent upon each other as Michael's talk covers client-side programming and mine covers server-side though the two can be used as endpoints for the other's demo portion.— John Dubchak—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

Published on Oct 6, 2016http://CppCon.org—Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016—Many IoT (Internet of Things) devices have adopted MQTT (Message Queueing Telemetry Transport) as an efficient protocol for communication. Few IoT devices have embraced modern C++ as a viable language for implementations. MQTT is a reliable publish-subscriber based messaging protocol that can be found in diverse ecosystems such as servers, cell phones, and light bulbs. Unfortunately, existing open source libraries leave much to be desired and many are a rich source of bad practices when compared to modern techniques. This session will explore maqiatto, CiereLab's open source MQTT client library written for embedded systems in modern C++ . There will be a brief demonstration of the library followed by digging into the design and implementation while providing the resource "cost" of various solutions. As we explore the C++14 code base to illustrate useful idioms and techniques for your own code we will answer the questions, what does is take to put modern C++ on a small OS-less device or a cell phone? Are there features to avoid? Join us and see how libraries can be elegantly designed and implemented for big or small targets alike.— Michael CaisseCiere, Inc.Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com—Videos Filmed & Edited by Bash Films: http://www.BashFilms.com