The C++Now Call for Submissions for 2014 is out. You might think that after releasing it, we just sit back and wait for all the great submissions to come rolling it. I hope it looks that easy to the outside world, but truth is that encouraging potential speakers to submit sessions is a year-round job that just gets more intense after the Call the Submissions. We are constantly looking for people with interesting things to say about C++ and asking them if they’d like to share at C++Now.

In 2012, when we changed the conference name from BoostCon to C++Now, we also added a third track of presentations. We wanted to create space for tutorials, specifically tutorials on the new language and library features. For this track, we are not just looking for good speakers, we also are looking for coverage of specific topics.

This year Scott Schurr is leading the effort to make certain that we are presenting an excellent tutorial track. I’ve his permission to share some of the ideas that we are pursuing.

Although some of the talks have been proposed with specific presenters in mind, most of these talks are “unclaimed” by any particular presenter. Why am I sharing them? Boost is an open-source library and I thought we could experiment with adding some transparency to our conference planning.

I’m also hoping that this list might be inspirational. Perhaps it will inspire you to claim one of these topics for yourself and make a submission of it or a completely different topic (the deadline is December 8th). If you have any ideas or questions about making a submission, you can contact the program committee. If you’d just like to comment on the list, you can do that at google plus or redit.

“Moving Well.” Guidance for the best way(s) to design a movable class. This can be complicated by interactions between movability and perfect forwarding (See Scott Meyers’ reflections on this problem at http://scottmeyers.blogspot.com/2013/07/video-for-universal-referenceoverloadin.html

“How and Why to Implement Value Semantics in C++”.” This talk might start out with an introduction to the ideas behind value semantics. A talk that discusses moving, deleting, defaulting, explicit conversion functions and delegating construction would be very valuable.

“The Libraries That You Should Know About.” Consider the “optional” library (no longer in C++14), “flat_set”, and reference wrappers. Consider about 5 minutes each on twelve small libraries. This could include standardized but under-appreciated libraries as well as Boost and Adobe Source Libraries.

“Unicode Support in Standard C++.” A lot of work has gone on here. What can you do with Unicode and just standard C++ in real-life situations?

“Intro to Functional Programming in C++.” What’s the point of functional programming. Don’t I have to do that in Haskell? Is functional programming an all-or-nothing thing? Can I benefit from making my C++ “more functional”? If so, how would I do that?

“Intro to Concurrency.” Obviously this could span two or three sessions and would make a terrific workshop.

“A Survey of Algorithms.” If you haven’t seen Sean Parent’s talks at Going Native, stop reading this and go watch them. ( http://channel9.msdn.com/Events/GoingNative/2013/Cpp-Seasoning http://channel9.msdn.com/Events/GoingNative/2013/Inheritance-Is-The-Base-Class-of-Evil

“How To Do Random Numbers Right (and How Not To Do Them).” We should ask STL to do his talk from Going Native as a tutorial.

“RegEx in C++.” STL did a great tutorial on this at Going Native. We could ask STL for a repeat, or we could ask someone else to give their take on it.

“Building Great Hashing Functions.” Perhaps this could be combined with bucket size/rehashing strategies for unordered containers.

“Fixed Size Arrays.”

“Alignment Control in C++11.” Most programmers don’t think about alignment. This talk could start with an introduction to alignment including where the requirement comes from. From there the talk could go into aligneof, alignas, aligned_storage. It could finish up with a discussion of over aligned data types (see N3396) and how to manage them.

“How To Build a Perfect Function Wrapper.” Suppose I want to do “something.” (I always use the example of timing how long we spend inside an API. This is conceptually very simple. You just start timing when you are about to make an API call and stop when you finish.) But you want to be able to wrap arbitrary calls. So you need to use variadic template parameters and perfect forwarding. This may be too simple to justify a complete session. Maybe it could be combined with a tutorial on bind, function, and lambda. (Or a tutorial on the time library.)

“Managing Object Lifetimes.” Start with RAII, move on to smart pointers, then show how the combination gives you 90% of the exception-safety that you want. Finish up with a discussion on passing parameters – how to make your APIs be more explicit about ownership and lifetimes.

“Compilation Errors: The Best Kind of Errors.” When I’ve tried talking to typical programmers about compile-time error checking they lift their noses and suggest that it couldn’t be useful. But with careful design many kinds of errors (admittedly not all) can be hoisted to compile-or link-time. We need to promote finding programming errors early.

“SFINAE Boot Camp.” This is a really important technique that is more of a black art than a science. If someone can present rhyme and reason for how to use SFINAE in a variety of circumstances I think a lot of people would benefit from that.

“Understanding &&.” You’ve no doubt noticed that && in a signature does not act like & or * in a signature. A session that helps folks develop an intuition for && and its effects would be great. All the experts already have this nailed, but this could be a valuable topic for mid-level programmers. Perhaps this topic could incorporate the first topic, “Moving Well.”

“New Features in C++14.” Surely we ought to cover this topic.

“C++11/14 Glossary.” C++11 extends rvalues and lvalues to include a total of five different values categories. PODs used to be important, but now aggregates, trivial classes, and standard-layout classes carry more of the semantic load. The volatile keyword has a new meaning in C++11 that it didn’t have in C++98. A deep dive into some of these vocabulary changes (and others) could be useful for many mid-level programmers.

“What’s My Value?” To mix it up a bit, we could do C++ related questions in some sort of game show format. Imagine 45 minutes of glossary followed by a 45 minute game show format presentation with questions about the preceding material. This could also be applied to a talk about the memory model followed by game show style questions.

“Building a Boost Reference Application.” Boost could have a reference application (or maybe several) which uses many Boost libraries to do something useful. The reference application would be an example of how to use Boost libraries in the real world.

Topics that don’t focus on a specific feature. The Meeting C++ conference ( http://meetingcpp.com/index.php/schedule13.html Simpler C++ code through C++11 Clean C++ – throw down the gauntlet against software entropy! Generic Programming for the rest of us Efficient Team Development for C++ Projects Presentations on tools C++ developers typically use or might want to

“Presentations on tools C++ developers typically use or might want to use: Git, CMake, Quickbook (and how to use the tool chain to generate documentation) etc.

Workshop to organize “review teams” (probably easier than finding individuals who have to do all the work 🙂 which start working their way through the libraries in the review queue (“Review manager in a week” instead of “Library in a week”? 😉

“Google Summer of Code.” This is a successful program. Can we leverage it into a useful tutorial topic?

“C++11/14 Overview: Core Language Features” C++ Timeline Goals for C++11 The Simpler Core Language Features auto, decltype, trailing return types nullptr Range for >> in template specializations static_assert noexcept extern template constexpr

“C++11/14 Overview: Features Specific to Class Design” Generated functions: default / delete Override control: override / final Delegating constructors Inheriting constructors Increased flexibility for in-class initializers Explicit conversion operators

“C++11/14 Overview: Larger Language Features” Initialization Initializer lists Uniform initialization Prevention of narrowing Lambdas Rvalue references, move semantics, perfect forwarding: lvalues and rvalues (the modern view) “move” semantics Universal references Perfect forwarding

“C++11/14 Overview: Concurrency” Threads Passing arguments to threads Data lifetime considerations Synchronization with mutexes and locking Returning values from threads using async() and futures Condition variables Thread-local storage Atomics



Please comment on Google Plus or reddit.

Share this: Twitter

Reddit

LinkedIn

Facebook

More

Print

Email





Like this: Like Loading...