C++Now trip report by JetBrains
It’s been a while since C++Now 2017 wrapped up in Aspen. As it was my first C++Now, I took some time to think it over before sharing my impressions. By the way, there are other trip reports: by Ben Deane, Michael Park and Odin Holmes.
In a few words, it was a fantastic opportunity to dive into cutting-edge C++, and hopefully survive. That means not only successfully escape from a major storm in Denver and Aspen’s snowy weather, but also meet dozens of clever people and dive into crazy ideas and libraries, that will become your everyday C++ routine tomorrow.
One exceptional thing about C++Now sessions, which makes this conference unique in comparison to CppCon, Meeting C++ and others, is a drive for discussions and collaboration. JetBrains is a C++Now video sponsor this year and, together with Bash Films, we make sure you’ll get high-quality video content from this year’s conference. Still, many valuable points will unfortunately be lost as they could not be recorded. Only there, high up in the Aspen mountains, could you experience:
- Live discussions during the talks
- Free-time discussions
- Library-in-a-week activity and work on proposals going on day and night (sometimes literally!)
C++ developers come to Aspen to contribute to the language, work on libraries that may later be included as a part of the standard, evaluate various proposals implementations, and suggest bright and revolutionary ideas and solutions to other developers.
For us, a tool vendor, this was a great opportunity not only to get a glimpse into how the language is evolving, but also to understand how to enhance our tools now so that they best work for C++ developers tomorrow.
In particular, I’d like to share my impression of Alisdair Meredith’s talk about std2 (part 1, 2, part 3 is not yet available). It took three sessions and became more and more interactive with each one. Some ideas that I was very happy to hear:
- Modules-based approach, meaning that each header is replaced with a single import and deprecate headers. A good point up for debate is whether it’s better to go with one
stdmodule, a module per header or some intermediate balanced approach with modules per piece of functionality (work with streams, text-handling, various algorithms, etc.).
- Concept usages, which is good on its own but raises a big question on how to proceed with existing constraints and avoid pure concepts vocabulary in std. There is also the question of eliminating type traits with concepts and reflection.
Another good question about new namespace was raised: Is it possible to have two co-existing top-level namespaces? Is it possible to import symbols from one into other?
Alisdair discussed compatibility questions with the audience and suggested some additions. What we met in Aspen was a better but still compatible std, which we may expect to try in C++20 and delivered by C++23.
Jackie Kay gave an exciting talk about reflection. For the end user, reflection opens up fantastic possibilities, while for the tool vendor it brings more or less pain depending on the implementation. I was very interested in the range of options, from the currently available schema-based generation, compile-time generation with libclang, and reflection macro like one from Boost.Hana and more, to some fresh suggestions like reflexpr and operator$/cpp3k.
I especially liked that the talk was full of samples which helped understand the suggestions better, as well as see some obvious and nonobvious pros and cons in each case. If you’d like to experiment with the solutions and see some benchmarks, check out Jackie’s repo at GitHub.
CMake was my primary build tool before JetBrains, and it’s currently the only project model in CLion. Still it’s possible to surprise me with some CMake-related talk. Case in point: Daniel Pfeifer’s talk on modern CMake was regarded as the Most Educational talk. A short summary of Daniel’s advice:
- Modern CMake is not about variables (which are easy to break, because you’ll get an empty string as soon as you make a typo in the variable), but about targets and properties, which are safer and you can work with them as if they were objects (in OOP sense).
- Don’t use commands that operate at directory level.
- Don’t use CMAKE_CXX_FLAGS, but better specify requirements and let CMake figure the compiler flags to use, as it’s the safer way to go.
- Use a Find Module for 3rd party libraries that do not support clients to use CMake (like Boost). Others provide packages that can be included by using Find Package (even when they are not using CMake for their own build, like Qt).
Daniel also talked about CTest, CPack and some code analysis tools, and really impressed me with a list of directions in which CMake can theoretically evolve in the future (that was Daniel’s personal wish-list but I do really support many ideas from there):
- PCH as usage requirements, so that CMake takes care of building the PCH and force-includes this header to the compilation units.
- Allow things like Protobuf, Qt-resources and other IDL to be treated like a language by CMake.
- Lua VM (execute CMake commands on Lua VM and allow CMake modules written in Lua).
I was impressed by lightning talks as well. They were both fun and educational, and I even think that two 2-hour evenings are not enough; a third day of lightnings would be a great addition. By the way, we played this cute joke during lightnings:
Over to Phil
It was also my first C++Now and I can attest to most of Anastasia’s first impressions. It’s a unique conference in so many ways: the setting, the people, the sessions, the after-sessions – even the accommodation (it’s a spa resort, if you stay on campus).
Of course in terms of content it was top-notch. This is primarily an experts-to-experts exchange (having its roots in BoostCon), and it shows. It’s not that the material is necessarily all too advanced for the average developer. Most of it was surprisingly accessible. But for many speakers (myself included, on this occasion) it was an opportunity to share what we’re doing or what currently interests us – often as a “thinking out loud” exercise where we invite active discussion and feedback – knowing that some of the best minds in the community are around.
Highlights for me were Tony Van Eerd’s “Postmodern C++” which was entertaining but also thought provoking in part; Peter Bindel’s “Mocking C++”, which pulled out all the stops in abusing the language to achieve what many thought was impossible in C++; and Mark Zeren’s “Rethinking Strings” which dovetailed nicely with some of my own thoughts that I have been presenting as part of my Functional C++ talks. Unfortunately I missed many that I had been looking forward to seeing as I was still spending a lot of time getting ready for my own talk, including: “constexpr ALL the things” (Jason Turner and Ben Deane), and “Postmodern Immutable Data Structures” (Juanpe Bolivar). It was sad leaving Aspen behind.
Next week I’ll be at NDC Oslo and the Italian C++ conference in Milan the weekend immediately after, giving three talks between them (“Functional C++ for Fun and Profit”, twice, and “Swift For The Curious”) and working at the booth in both locations. So if you’re around, please do come and say “Hi!”.
(now back to Anastasia)
Jon Kalb also recorded a special episode of his CppChat during the event. It was a great gathering of people (and I was happy to join!) who discussed their impression of this year’s C++Now. Conference volunteers and speakers were happy to share their thoughts and give reasons for visiting C++Now.
Weather, deer and the mountains
I had been told of the wonderful mountains views in Aspen, but what I saw really impressed and delighted me.
I was prepared to see some bears, but instead met deer early in the morning near my hotel room. It has to be Spring in the mountains, but temperatures fell down during the after-lunch talk on Wednesday and it was snowing until Friday. Still, I enjoyed the warmed open swimming pool:
You may expect anything from C++Now, but one thing is for sure – there you’ll find great content and lots of new friends among highly professional C++ developers who care about the future of the language.