The second in a series of recorded talks from GoingNative 2013. Featuring Stephan T. Lavavej.
The second in a series of recorded talks from GoingNative 2013. Featuring
Stephan T. Lavavej.
</p></short>
<abstract><p>
The second in a series of recorded talks from GoingNative 2013. Featuring Stephan T. Lavavej.
The second in a series of recorded talks from GoingNative 2013. Featuring
Stephan T. Lavavej.
</p><p>
C++ has powerful rules for dealing with low-level program structure. Before a program is ever executed, the compiler determines valuable information about every expression in the source code. The compiler understands exactly how long each object's resources will be needed (lifetime), whether each expression refers to an object that the program has no other way of accessing (rvalueness), and what operations can be performed on each object (type). Using examples from C++98 through C++14, this presentation will demonstrate how to write code that works with the compiler's knowledge to increase robustness, efficiency, and clarity. This presentation will also demonstrate the horrible things that happen when programmers think they can do tasks that are better left to compilers.
C++ has powerful rules for dealing with low-level program structure.
Before a program is ever executed, the compiler determines valuable information
about every expression in the source code. The compiler understands exactly
how long each object's resources will be needed (lifetime), whether each
expression refers to an object that the program has no other way of accessing
(rvalueness), and what operations can be performed on each object (type).
Using examples from C++98 through C++14, this presentation will demonstrate how
to write code that works with the compiler's knowledge to increase robustness,
efficiency, and clarity. This presentation will also demonstrate the horrible
things that happen when programmers think they can do tasks that are better
left to compilers.
</p></abstract>
</eventitem>
<eventitemdate="2013-10-31"time="6:30PM"room="PHY 150"title="C++ Night 0x03 - An Effective C++11/14 Sampler">
The third in a series of recorded talks from GoingNative 2013. Featuring Scott Meyers.
The third in a series of recorded talks from GoingNative 2013. Featuring
Scott Meyers.
</p></short>
<abstract><p>
The third in a series of recorded talks from GoingNative 2013. Featuring Scott Meyers.
The third in a series of recorded talks from GoingNative 2013. Featuring
Scott Meyers.
</p><p>
After years of intensive study (first of C++0x, then of C++11, and most recently of C++14), Scott thinks he finally has a clue. About the effective use of C++11, that is (including C++14 revisions). At last year’s Going Native, Herb Sutter predicted that Scott would produce a new version of Effective C++ in the 2013-14 time frame, and Scott’s working on proving him almost right. Rather than revise Effective C++, Scott decided to write a new book that focuses exclusively on C++11/14: on the things the experts almost always do (or almost always avoid doing) to produce clear, efficient, effective code. In this presentation, Scott will present a taste of the Items he expects to include in Effective C++11/14.
After years of intensive study (first of C++0x, then of C++11, and most
recently of C++14), Scott thinks he finally has a clue. About the effective use
of C++11, that is (including C++14 revisions). At last year’s Going Native,
Herb Sutter predicted that Scott would produce a new version of Effective C++
in the 2013-14 time frame, and Scott’s working on proving him almost right.
Rather than revise Effective C++, Scott decided to write a new book that
focuses exclusively on C++11/14: on the things the experts almost always do (or
almost always avoid doing) to produce clear, efficient, effective code. In this
presentation, Scott will present a taste of the Items he expects to include in
Effective C++11/14.
</p></abstract>
</eventitem>
<eventitemdate="2013-11-07"time="6:30PM"room="PHY 150"title="C++ Night 0x04 - Writing Quick Code in C++, Quickly">
The fourth in a series of recorded talks from GoingNative 2013. Featuring Andrei Alexandrescu.
The fourth in a series of recorded talks from GoingNative 2013. Featuring
Andrei Alexandrescu.
</p></short>
<abstract><p>
The fourth in a series of recorded talks from GoingNative 2013. Featuring Andrei Alexandrescu.
</p><p>
Contemporary computer architectures make it possible for slow code to work reasonably well. They also make it difficult to write really fast code that exploits the CPU amenities to their fullest. And the smart money is on fast code—we’re running out of cool things to do with slow code, and the battle will be on doing really interesting and challenging things at the envelope of what the computing fabric endures.
The fourth in a series of recorded talks from GoingNative 2013. Featuring
Andrei Alexandrescu.
</p><p>
So how to write quick code, quickly? Turns out it’s quite difficult because today’s complex architectures defy simple rules to be applied everywhere. It is not uncommon that innocuous high-level artifacts have a surprisingly high impact on the bottom line of an application’s run time (and power consumed).
Contemporary computer architectures make it possible for slow code to work
reasonably well. They also make it difficult to write really fast code that
exploits the CPU amenities to their fullest. And the smart money is on fast
code—we’re running out of cool things to do with slow code, and the battle will
be on doing really interesting and challenging things at the envelope of what
the computing fabric endures.
</p><p>
This talk is an attempt to set forth a few pieces of tactical advice for writing quick code in C++. Applying these is not guaranteed to produce optimal code, but is likely to put it reasonably within the ballpark.
So how to write quick code, quickly? Turns out it’s quite difficult because
today’s complex architectures defy simple rules to be applied everywhere. It is
not uncommon that innocuous high-level artifacts have a surprisingly high
impact on the bottom line of an application’s run time (and power consumed).
</p><p>
These tips are based on practical experience but also motivated by the inner workings of modern CPUs.
This talk is an attempt to set forth a few pieces of tactical advice for
writing quick code in C++. Applying these is not guaranteed to produce optimal
code, but is likely to put it reasonably within the ballpark. </p><p>
These tips are based on practical experience but also motivated by the
inner workings of modern CPUs.
</p></abstract>
</eventitem>
<eventitemdate="2013-11-21"time="6:30PM"room="PHY 150"title="C++ Night 0x05 - C++ Seasoning">
The fifth in a series of recorded talks from GoingNative 2013. Featuring Sean Parent.
The fifth in a series of recorded talks from GoingNative 2013. Featuring
Sean Parent.
</p></short>
<abstract><p>
The fifth in a series of recorded talks from GoingNative 2013. Featuring Sean Parent.
The fifth in a series of recorded talks from GoingNative 2013. Featuring
Sean Parent.
</p><p>
A look at many of the new features in C++ and a couple of old features you may not have known about. With the goal of correctness in mind, we’ll see how to utilize these features to create simple, clear, and beautiful code. Just a little pinch can really spice things up.
A look at many of the new features in C++ and a couple of old features you
may not have known about. With the goal of correctness in mind, we’ll see how
to utilize these features to create simple, clear, and beautiful code. Just a
