CppCon 2015: Last online videos (2)
The videos of CppCon 2015 are coming online. You can see them all here: Youtube or Channel 9
Here are the most recent ones:
- A Crash Course in Open Source Licensing
- Testing Battle.net (before deploying to millions of players)
- Stop Teaching C
- A C++14 approach to dates and times
- What is Open Source, and Why Should You Care?
- Comparison is not simple, but it can be simpler
- Contracts for Dependable C++
A Crash Course in Open Source Licensing by Kevin P. Fleming
Open source software licenses are intended to provide a way for software authors to protect their own rights, and the rights of the users of their software, but many developers are unaware of how they work, why they are important, and how to apply them to their projects.
It may never have occurred to you, but software licenses are much like programs: they are developed to meet requirements, they live in a world of external influences and constraints, and they use documented techniques to solve problems.
In this session, the attendees will participate in a fun, interactive process to choose the components of a software license through real-world examples, with the goal of every attendee leaving with a basic understanding of the more important aspects of software licenses. Along the way they will learn the basics of copyrights and how they apply to software; what 'derivative work' and 'distribution' mean in these contexts; and many other useful concepts, including the most important differences between common licenses like the GNU General Public License family and the Apache 2 license.
Testing Battle.net (before deploying to millions of players) by Ben Deane
Battle.net is the online service that runs Blizzard's games. As such, it is a large scale distributed system with many interacting parts and dependencies on various services and data. While developing Battle.net servers, I needed a way to isolate and test functionality that I was working on.
In this talk I will cover my experience designing for testability of components in a distributed system, and practical ways to structure classes and data to facilitate testing. I will also present my solution to the problem of testing my code for correctness, performance and scalability without having to deploy a full-scale environment and spin up a million clients.
Stop Teaching C by Kate Gregory
To this day most people who set out to help others learn C++ start with "introduction to C" material. I think this actively contributes to bad C++ code in the world. For the past few years I've been teaching C++ (and making suggestions to folks who intend to teach themselves) in an entirely different way. No char* strings, no strlen, strcmp, strcpy, no printf, and no [] arrays. Pointers introduced very late. References before pointers, and polymorphism with references rather than with pointers. Smart pointers as the default pointer with raw pointers (whether from new or &) reserved for times they're needed. Drawing on the Standard Library sooner rather than later, and writing modern C++ from lesson 1.
In this session I want to talk about the specific advantages of teaching C++ this way – a way that’s very different from the way you almost certainly learned the language. You’ll be pleasantly surprised to see what you get to leave for later or never cover at all, what bad habits you don't later need to correct, what complicated concepts actually become accessible to beginners, and how you spend a lot less time dictating magic spells you can't explain yet, and more showing someone a comprehensive, sensible, and understandable language.
You don't have to be a trainer to come to this session. If you ever mentor other developers and show them your C++ code, if you ever help somebody choose a book or a course or other material to learn from, or even if you occasionally feel bad that you work in a language that's hard to learn, come and see how one philosophical shift can turn that very same language into one that's actually pretty easy to learn!
A C++14 approach to dates and times by Howard Hinnant
A new date and date/time library designed for C++14 is presented. This library stresses ease of use, easy-to-read code, catching common errors at compile time, and uncompromising run-time performance.
The design starts with the C++11 std::chrono library, and extends it into the realm of calendars, giving a seamless experience built upon chrono::system_clock::time_point, the durations you already know such as chrono::hours and nanoseconds. Functionality that allows easy and efficient conversions between the std::chrono types and year/month/day - hh::mm::ss data structures is presented.
When dates (and times) are known at compile-time (e.g. leap second transitions), all computations are available at compile time (constexpr). When only parts of a date are known at compile time, run-time efficiencies are still gained by compile-time computing parts of the date.
The syntax of the library is built around a few easy-to-learn rules, and strictly checked at compile time. This makes it easy to learn, and very forgiving for the novice.
What is Open Source, and Why Should You Care? by Kevin P. Fleming
In this session, Kevin will present a condensed history of open source software: its origins, motivations and effect on the world of software development. He'll then talk about open source *beyond* software, and various ways that students can get involved in open source projects to develop useful (and marketable) skills. These are skills which are not taught in most degree programs, but are very valuable for jobs in scientific and engineering disciplines.
Comparison is not simple, but it can be simpler by Lawrence Crowl
The standard's algorithms typically require a 'strict weak ordering'. I will explain what this really means and show that even simple uses of sort can have latent failures. Programmers can avoid the problems today with a bit of work. Changes to the standard will reduce errors and programming effort.
Contracts for Dependable C++ by Gabriel Dos Reis
One of the three major areas that C++17 is expected to address is “improving support for large-scale dependable software.” A general understanding of ‘dependable software’ is the notion that the product should reliably perform the task it was designed for, and when given erroneous inputs the program should not be allowed to blindly continue execution, thereby possibly causing serious harms. In another words, an abrupt program termination is preferable to an exploited program vulnerability.
“Contracts” are a language feature being considered by the ISO C++ standards committee for C++17. They offer a basic mitigation measure, and early containment mechanism, by allowing a C++ programmer express more formally (instead of just comments) in code the requirements of a function interface. They offer a complement to conventional static type checking, and move comments closer to mechanized scrutiny. This presentation will explore the design space, previous efforts, the importance of analysis tools (both static and dynamic), and how contracts provide greater integration and support.
CppCon 2015's inspiring endnote video is now available below. This is last of the rush-processed plenary sessions posted quickly (see the Video feed for the others). Of course, there'll be more: Like last year, all the sessions, panels, and lightning talks were professionally recorded and will be available online worldwide for free, but processing well over 100 videos is a lot of work and it will take about a month before they can be available; your patience is appreciated.
Recorded at CppCon this week: