Loading…
This event has ended. Visit the official site or create your own event on Sched.
View analytic

Log in to bookmark your favorites and sync them to your phone or calendar.

•Design and Best Practice [clear filter]
Monday, September 25
 

11:00am

C++ Constraints: Background, Utility, and Gotchas
Compile-time constraints will likely soon become part of our routine C++ programming vocabulary. Why? Such constraints are induced by new core language features (requires-clauses and requires-expressions) that are on the horizon for C++. What are these all about?

Almost every function imposes requirements on its users; violating those requirements typically leads to incorrect programs. Historically, such requirements had to be expressed in comments or other documentation, as there was little machinery to express them in code. Soon we will be able to express more requirements in code, thus allowing compilers to detect and address more violations.

This talk aims to prepare both new and veteran C++ programmers with the necessary background, tutorial information, and advice to exploit this powerful new supplement to function declarations. A case study, illustrating an unexpected gotcha, will conclude the presentation.

Speakers
avatar for Walter E. Brown

Walter E. Brown

retired, none
With broad experience in industry, academia, consulting, and research, Dr. Walter E. Brown has been a C++ programmer for over thirty-five years, joining the C++ standards effort in 2000. Among numerous other contributions, he is responsible for introducing such now-standard C... Read More →


Monday September 25, 2017 11:00am - 12:00pm
Ferranti (403) Meydenbauer Center
 
Tuesday, September 26
 

9:00am

Function default arguments: Slingshot or Shotgun?
On the surface, function parameter default arguments seem like a very simple feature of the C++ language. This session explores how (not) true that is. If you like the dark corners of C++, you will come away with a new appreciation for this innocent looking syntactic sugar. Otherwise, you will have at least informed yourself on how not to blow your foot off with what looks like a slingshot.

Speakers
avatar for Michael Price

Michael Price

Senior Software Engineer, Synopsys, Inc.
Michael Price has developed and taught C++ for more than a decade and has been an active participant in WG21 since 2014, allocating most of his committee-time to EWG and the Reflection Study Group. He professes interest in making C++ "safer" to use through language and library de... Read More →


Tuesday September 26, 2017 9:00am - 10:00am
Harvard (406) Meydenbauer Center

9:00am

Mocking Frameworks considered harmful
Software development without test automation can no longer be considered professional.
However, you might have existing code bases or want to rely on external libraries that may make writing effective and fast unit tests hard or even near to impossible. A typical work-around for these situations is to introduce test stubs for such external dependencies to make your code testable.

Some propose to use mocking frameworks, such as GoogleMock, together with unit testing frameworks to ease the specification of the replacement objects. These mocking frameworks often come with their own domain-specific language (DSL) to describe the behavior and expected usage of the mock object. In addition to a learning curve, the DSLs often do not help much, when things do not work. The current lack of standardized reflection in addition requires macro trickery making fixing problems even harder. A second issue, is that existing code often must be prepared to suite the mocking frameworks interception mechanism to allow to inject the mock objects. Last but not least test-driven-development (TDD) together with the use of a mocking framework can lead to high coupling, that TDD usually strives to reduce.


This talk demonstrates "classical" mocking frameworks, shows the problems and demonstrates how Cevelop's Mockator approach can help refactoring existing code to get it under test and how a very simple plain C++ solution can be used instead of complicated mocking framework for unit tests with dependent code replaced by test stubs or mocks.

Outline:
* Introduction
** Fowler's Whisky Warehouse - classic example for Mocking Frameworks in C++
* Feathers' Seams: Dependency Injection
** Refactoring to Object Seams
** Refactoring to Template Seams
** Linker Seams
** Preprocessor Seams as a last resort
* Problem with "classic" Mocking Frameworks
* Simpler Mocking with Mockator
* Why and when you should not Mock

With a longer slot, more of the underlying test automation theory, based on xunitpatterns.com can be given.

Speakers
avatar for Peter Sommerlad

Peter Sommerlad

Professor, IFS Institute for Software
Prof. Peter Sommerlad is director of IFS Institute for Software at FHO HSR Rapperswil where he inspired the C++ IDE Cevelop. Peter is co-author of the books POSA Vol.1 and Security Patterns. His goal is to make software simpler by Decremental Development: Refactoring software dow... Read More →


Tuesday September 26, 2017 9:00am - 10:00am
ENIAC (404) Meydenbauer Center

10:30am

C++ as a "Live at Head" Language
Engineering is programming integrated over time. That is to say, as much as it can be difficult to get your code to build and run correctly, it is manifestly harder to keep it working in the face of changing assumptions and requirements. This is true no matter the scale, from a small program to a shared library. Only two solutions have been shown to be theoretically sound: never change or provide no compatibility guarantees. What if there were a third option? What if we took the question of maintenance out of the realm of theory and moved it to practice? This talk discusses the approach we've used at Google and how that intersects with other languages, package management, API and ABI compatibility, and a host of other software engineering practices. The particulars of C++ as a language and an ecosystem make it well positioned for a different approach: Live at Head.

Speakers
avatar for Titus Winters

Titus Winters

C++ Codebase Cultivator, Google
Titus Winters has spent the past 6 years working on Google's core C++ libraries. He's particularly interested in issues of large scale software engineer and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Alo... Read More →


Tuesday September 26, 2017 10:30am - 12:00pm
Atanasoff-Berry Hall Meydenbauer Center

2:00pm

Postmodern C++
The term "Modern C++" can be traced back to Andrei Alexandrescu's "Modern C++ Design", published in February 2001. Much has changed since then. Alexandrescu is off Dabbling in various things, Scott Meyers has retired; C++11 changed the landscape, then C++14, and now we are at C++17, with more on the way.

Clearly, we are now in the Postmodern C++ era.

So let's apply postmodernism to programming. YOU WON'T BELIEVE WHAT HAPPENS NEXT:
- How to concentrate on one section of a programme at a time, and test in isolation. QA HATES HIM.
- post-modern introspection?. IT WILL SHOCK YOU.
- you'll NEVER BELIEVE what a postmodern smart ptr LOOKS LIKE!

Although this is a lighthearted talk, it also aims to be insightful.
In fact, the goal is nothing less than to change the way you think about programming.

Speakers
avatar for Tony Van Eerd

Tony Van Eerd

Ninja/Jedi/Tony, Christie Digital
Tony has been coding for well over 25 years, and maybe coding well for some of that. Lots of pixel++, UX, threading, etc. Previously at Inscriber, Adobe, BlackBerry, he now enables Painting with Light at Christie. He is on the C++ Committee. He is a Ninja and a Jedi. Lock-free is... Read More →


Tuesday September 26, 2017 2:00pm - 3:00pm
ENIAC (404) Meydenbauer Center

3:15pm

Designing A Feature That Doesn't Fit
C++ is a wonderful and expressive language, that gives programmers a lot of freedom even though it actively seeks to let programmers obtain the maximal performance from their hardware. It so happens that sometimes, operating systems can make it easy to do things that are absolutely not natural for a C++ program, but that some C++ programmers consider essential to their practice.

This talk will explore the problem of adding functionality to the language, more specifically to the standard threading library, where said functionality is not a natural fit for the C++ language specification. Expressed otherwise: how can we find ways to meet the needs of users without corrupting the language we all love?

This talk will be more interesting to you if you have met situations where you wanted to do something in "pure C++" but found you had to resort to operating system-specific features to meet your objectives. We will discuss the design space that has been explored for the problem under study, and will try to make emerge the strengths and weaknesses of the various alternatives.

Speakers
avatar for Patrice Roy

Patrice Roy

Professor, Université de Sherbrooke / Collège Lionel-Groulx
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 20 years. After a few years doing R&D and working on military flight simulators, he moved on to academics and has been teaching computer science since 1998. Since 2005... Read More →


Tuesday September 26, 2017 3:15pm - 4:15pm
Harvard (406) Meydenbauer Center

4:45pm

Hands-On With Google's Common Libraries
An introduction to the design and compatibility goals for Abseil - Google's new common C++ libraries project. I'll summarize some style points and policies that affect Abseil and its users, and demo hands-on many of the debugging features of the library. 

Speakers
avatar for Titus Winters

Titus Winters

C++ Codebase Cultivator, Google
Titus Winters has spent the past 6 years working on Google's core C++ libraries. He's particularly interested in issues of large scale software engineer and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Alo... Read More →


Tuesday September 26, 2017 4:45pm - 5:45pm
Colossus Theater Meydenbauer Center

4:45pm

Recreational C++
C++ is a language full of curiosities, and entices the curious. This session will will walk through half a dozen little code explorations of ideas that might have been solved in 5 minutes, but piqued my curiosity to keep digging and see just how completely or thoroughly they might be solved, and what we can learn about the language and the way it holds together along the way. Fundamentally, it is about the joy of exploring code long after the problem has been solved, to find those satisfying solutions to problems that don't need solving!

There will not be much deep learning; instead, there will be numerous insights into corners of the language that are often (for good reason!) unexplored, that might help with the big picture when debugging some obscure bugs. In particular, constexpr and templates will be exercised, and some compiler limits may be tested. We will demonstrating code that will the the gamut of C++98 though to C++17, and even poke into experimental pending features such as concepts.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

Senior Software Developer, Bloomberg LP
Alisdair Meredith is a software developer at BloombergLP in New York, and the C++ Standard Committee Library Working Group chair. | | He has been an active member of the C++ committee for just over a decade, and by a lucky co-incidence his first meeting was the kick-off meeting... Read More →


Tuesday September 26, 2017 4:45pm - 5:45pm
Atanasoff Hall Meydenbauer Center
 
Wednesday, September 27
 

9:00am

10 Core Guidelines You Need to Start Using Now
The C++ Core Guidelines were announced at CppCon 2015, yet some developers have still never heard of them. It's time to see what they have to offer for you, no matter how much C++ experience you have. You don't need to read and learn the whole thing: in this talk I am pulling out some highlights of the Guidelines to show you why you should be using these selected guidelines. For each one I'll show some examples, and discuss the benefit of adopting them for new code or going back into old code to make a change.

Beginners who find the sheer size of the language and library daunting should be able to rely on the Guidelines to help make sane choices when there are many ways to do things. Experienced C++ developers may need to leave some of their habits behind. Developers along this spectrum could benefit from seeing what the Guidelines have to offer, yet the guidelines themselves are just too big to absorb all at once. My examples will be chosen to be beginner-friendly and the focus will be on what's in it for you: faster code, less bugs, and other tangible benefits.

Speakers
avatar for Kate Gregory

Kate Gregory

Partner, Gregory Consulting
Kate Gregory has been using C++ since before Microsoft had a C++ compiler. She writes, mentors, codes, and leads projects, in both C++ and .NET, especially for Windows. Kate is a Microsoft Regional Director, a Visual C++ MVP, and has written over a dozen books (the most recent on C++ AMP for Microsoft Press) and speaks at conferences and user groups around the world. Kate develops courses on C++, Visual Studio, and Windows programming for Pluralsight, founded the East of Toronto .NET Users group, and is a member of adjunct faculty at Trent University in Peterborough.Website... Read More →


Wednesday September 27, 2017 9:00am - 10:00am
Atanasoff Hall Meydenbauer Center

2:00pm

Naivety of Creating Cross-Platform, Modern C++ Libraries: A Tour Of Our Challenges and Successes
The AWS SDK for C++ was designed with a few important tenets. Modern C++ (versions 11 and later), Cross-Platform, User Customization with sane defaults, and no dependencies. A year after launching for general availability, we've been thinking about how these tenets have served us well, and the challenges we've encountered when applying them.

In this talk, we will discuss the difficulties we encountered in design and implementation, and then we will cover the aspects of our design that have worked out well. The topics we will cover are: Build System choices, the C++ standard library, Dependency choices, Threading models, Memory models, IO-based programming, ABI compatibility, and packaging.

Speakers
avatar for Jonathan Henson

Jonathan Henson

Senior Software Dev. Engineer, Amazon Web Services, Inc
Jonathan is a Senior Software Engineer at Amazon Web Services. He leads development on the AWS SDK for C++ and is passionate about writing tooling for modern C++ developers and advancing adoption of the latest C++ standards.


Wednesday September 27, 2017 2:00pm - 3:00pm
Harvard (406) Meydenbauer Center
 
Thursday, September 28
 

9:00am

A Test a Day Keeps Your Manager Away!
This session will present how to leverage C++'s diverse set of analysis tools with existing Continuous Integration services to increase a project's quality continuously over time. In additional, we will discuss the advantages and disadvantages of using these tools using real world open source examples. Those interested in Continuous Integration or learning new ways to increase the quality of their code will enjoy this presentation.

Continuous Integration (CI) is the act of continuously integrating small changes to a code base. The goal is to identify integration issues prior to making a change, ensuring a project's quality over time. Thanks to virtualization, today we have many services that provide automated continuous integration that support C++ including Travis CI and AppVeyor on Windows, Linux and MacOS. Typically CI is used to compile and sometimes execute automated tests to ensure a change to a project doesn't result in a compilation issue, or regression. C++ is however is a diverse, rich environment with numerous analysis tools available to C++ developers. These tools can be integrated into these CI services to provide automated analysis of any change being made to a project prior to it's acceptance to ensure the highest possible quality of the project.

During this session we will step through an open source project designed to demonstrate how to integrate different C++ analysis tools into your CI services. These tools include static analysis (Clang Tidy, Coverity Scan, Codeacy and CppCheck), dynamic analysis (Valgrind and Google's Sanitizers), source formatting (Astyle and Clang Format), documentation (Doxygen), code coverage (Codecov, Coveralls, and LLVM's Software-based Code Coverage), cross platform tests (Windows, Cygwin, Linux, and macOS), compiler tests (GCC, Clang, and Visual Studio) and finally C++ libraries designed to assist in reliability and automated testing (Catch, Hippomocks and the Guideline Support Library). In addition we will openly discuss the advantages and disadvantages of using various analysis tools, how to integrate these tools into existing projects (both large and small) as well as common problems encountered while using these tools autonomously in a CI environment.

Speakers
avatar for Rian Quinn

Rian Quinn

Senior Engineer, AIS, Inc.
Dr. Rian Quinn is a Senior Principal Investigator in the Trusted Information Systems Group at Assured Information Security, Inc. were he has focused on trusted computing and hypervisor related technologies for nearly 10 years. He holds a Ph.D. in Computer Engineering with special... Read More →


Thursday September 28, 2017 9:00am - 10:00am
ENIAC (404) Meydenbauer Center

2:00pm

How to Write Effective Documentation for C++ Libraries with Minimal Effort
With the success of GitHub, everybody and his brother is a library developer. Programmers love to create code, upload it to GitHub and hope for immortality. Most projects get only the most cursory examination before being passed over by users. Why is that? GitHub considered the problem.

GitHub just published its 2017 Open Source Survey. The popular social coding service surveyed over 5,500 members of its community, from over 3,800 projects on github.com. It also spoke to 500 coders working on projects from outside the GitHub ecosystem. The Open Source Survey asked a broad array of questions. One that caught my eye was about problems people encounter when working with, or contributing to, open source projects. An incredible 93 percent of people reported being frustrated with “incomplete or confusing documentation”. see https://thenextweb.com/dd/2017/06/02/free-software-is-suffering-because-coders-dont-know-how-to-write-documentation/#.tnw_SYGx5ozW

Even the most experienced and dedicated software developers can't do it. This can be confirmed by looking over recent reviews of Boost libraries. The most common complaint is that the documentation isn't useable.

Programmers love their stuff and hope to get people to use it, why don't they fix their documentation? The reason is simple: They don't know how.

Problems

a) It's tedious and boring to write
b) Developers don't know what to include and what to exclude
c) Tools make things harder
d) Regardless of the amount of effort invested, the end result is usually of little or no value.

This presentation will present a "Cookbook" and demonstration for creating documentation. Using this method will

a) Much diminish the tedium of the task.
b) Help improve to the quality of library design and implementation
c) Create something that is useful to the library user.

We will touch upon tools like Doxygen, etc. But this is only a small portion of the presentation. We use them so they deserve mention. But they don't cause the problem, and they don't solve it either.

Speakers
avatar for Robert Ramey

Robert Ramey

Proprietor, Robert Ramey Software Development
Robert 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 dev... Read More →


Thursday September 28, 2017 2:00pm - 3:00pm
Ferranti (403) Meydenbauer Center

2:00pm

Mix Tests and Production Code With Doctest - Implementing and Using the Fastest Modern C++ Testing Framework
Not a typical talk about testing. Here are some quotes from the Program Committee about it:

  • "Seeing a talk proposal about a new unit test framework made me quite skeptical. But then I looked at slides from one of the previous talks, and this looks very cool."
  • "I think others will be just as interested; this is just the kind of talk we want at the conference."
  • "Doing interesting and meaningful things in header-only libraries can be a fascinating topic, and this presentation appears to address some very interesting learnings from such an experience."
  • "The presentation is clearly well-prepared, having been given previously and iterated upon."

  • doctest
    is new to the C++ testing framework scene but is by far the fastest both in compile times (by orders of magnitude) and runtime compared to other such feature-rich alternatives.

    It brings the ability of compiled languages such as D / Rust / Nim to have tests written directly in the production code by providing a fast, transparent and flexible test runner with a clean interface which can be removed entirely from the binary along with all tests for release builds of the software that are shipped to customers.

    The framework can be used like any other even if you don't want/need to mix production code and tests - the list of features doesn't stop growing.

    By attending this talk you will get familiar with the framework and see how it's different from all the rest.

    To make things more interesting the presentation will not just focus on using the framework, but will delve into useful and generally applicable C++ techniques from its implementation for more than half the session length which can be applied in different areas of your work - like how to:

    • register code automatically before the program enters main()
    • decompose expressions with templates
    • translate exceptions - type-erased user-registerable translators
    • write a header-only library which compiles very very fast not at the cost of runtime performance
    • implement assert macros that don't result in code bloat
    • deal with warnings outside of the framework header - generated by code expanded from macros
    • loop a void owl once with while((void)0,0)

    Speakers
    avatar for Viktor Kirilov

    Viktor Kirilov

    With 3.5 years of professional experience with C++ in the games and VFX industries, Viktor currently spends his time writing open source software (since 01.01.2016). His interests are the making of games and game engines, high performance code, data oriented design, minimizing friction and incorporating good practices in the software development process such as testing and the use of modern tools like static analysis or instrumentation. Viktor is from Sofia, Bulgaria and his profession is his hobby... Read More →


    Thursday September 28, 2017 2:00pm - 3:00pm
    Harvard (406) Meydenbauer Center
     
    Friday, September 29
     

    1:30pm

    Curiously Recurring Bug Patterns in C++ at Facebook
    I've spent the last few years watching Facebook's C++ codebase grow by several orders of magnitude. Despite constantly improving abstractions, constantly improving tooling, frequent internal courses, and ongoing internal discussion, there are bug-patterns we simply cannot stop from being reintroduced into our code. My hope is to show some of the most common (and infamous) bugs in our history, and the surprising complexity that arises in some apparently simple situations.

    This talk serves the dual purpose of educating the intermediate (and perhaps the occasional advanced) C++ programmer about some really nasty common pitfalls, as well as serves as a plea to experts to help further improve the language, libraries, and best practices to help educate and eradicate some of these problematic patterns.

    Speakers
    avatar for Louis Brandy

    Louis Brandy

    Engineering Director, Facebook
    My team is responsible for the overall health of the Facebook C++ codebase, both the tools and the libraries. We work on: compilers, static/dynamic analysis, linters, large scale changes, and the core libraries.


    Friday September 29, 2017 1:30pm - 2:30pm
    Atanasoff Hall Meydenbauer Center
    • Level Intermediate, Advanced, Expert
    • Tags bugs

    1:30pm

    Free Your Functions!
    You are devoted to minimize coupling and duplication? You are taking care to maximize cohesion, flexibility, extensibility, encapsulation, testability, and even performance in order to achieve the high goals of (object-oriented) programming? Awesome! But wait: You still favor member functions? Seriously? You have been deceived! You have been praying at the altar of false promises! Shed the shackles of Java philosophy! Free your functions!

    In this talk I will demonstrate why in C++ free functions should generally be preferred to member functions, and why free functions — not member functions! — provide you with all the aforementioned advantages you expect from object-oriented programming. Note, though, that this talk might fundamentally change your perception of C++ and object-oriented programming in general!

    Speakers
    avatar for Klaus Iglberger

    Klaus Iglberger

    Senior Software Engineer, Siemens
    Klaus Iglberger has finished his PhD in computer science in 2010. Back then, he contributed to several massively parallel simulation frameworks and was active researcher in the high performance computing community. From 2011 to 2012, he was the managing director of the central in... Read More →


    Friday September 29, 2017 1:30pm - 2:30pm
    Colossus Theater Meydenbauer Center