The Renaissance of C

The Renaissance of C++
by Victor Haydin, Head of R&D Office, ELEKS

Agenda
A bit of C++ history
Why C++ is popular again?
The future of C++

Quick Survey
What programming languages do you know?

The Prehistoric Age
(1979-1989)

Research:
C with Classes
ARM C++

The Classic Age
(1989-1999)

Mainstream:
Wide usage
standardization

The Dark Age
(1999-2009)

Coffee-based languages domination:
Productivity over Efficiency
People over Hardware

Let’s compare them all
Efficiency Flexibility Abstraction Productivity
C
Efficient high-level + + Non-goal Non-goal
portable code

C++
C + efficient + + + Non-goal
abstraction

Java/C#
Productivity At the expence of At the expense of + +

Perception

Performance
& Control Productivity

Reality

Performance Productivity
& Control

C++ Values
 Never compromise on performance and control.
 Efficient abstraction (e.g., inlining by default)
 Flexibility to express exactly what you need (e.g., specialization)
 Exact control over memory layout (e.g., stack/member allocation)
 Determinism and ordering WYSIWYG (e.g., stack/member lifetime)
 Deeply believe in trust and zero overhead.
 “Leave no room for a language lower than C++” other than asm
 “Zero overhead” / “Don’t pay for what you don’t use”
 “Trust the programmer” (  pitfalls! still give usability, guard rails)
 “Always provide a way to open the hood and get down to the metal”

Priorities
 C++ says:
“Provide default-on guard rails and programmer productivity too,
but never at the expense of performance and control.”

 Coffee-based languages say:
“Provide performance and control too, but never at the expense
of always-on guard rails and programmer productivity.”

Change drivers
Mobile
Cloud/Datacenter
Platform shifts

Vendor’s point of view

1st version N/A Java .NET
2nd version Objective-C, C, C++ Java, C, C++ .NET, C++

Power consumption

57% Hardware +
31% Power = 88%
of expenses are directly
dependent on efficiency

The Renaissance
(2009-2019)

Return of the King:
C++11
Productivity tools

Developer survey
Q: How long has your current application been in development? (N=387)

C++11
 Corollary: Lots of what people “know” about C++ is no longer true.
 Changes to coding style/idioms/guidance.
 That’s why it feels new. Style/idioms/guidance define a language.

 Features that significantly change style/idioms/guidance include:

Taste of C++11
string flip( string s ) {
reverse( begin(s), end(s) );
return s;
}

int main() {
vector<future<string>> v;

v.push_back( async([]{ return flip(" ,olleH"); }) );
v.push_back( async([]{ return flip( ".gnaL"); }) );
v.push_back( async([]{ return flip("n!TXEN"); }) );

for( auto& e : v ) {
cout << e.get();
}
}

Taste of C++11
always there: scoped lifetimes
return s;
by construction (stack, member)
}
 strongly exception-safe
int main() {
vector<future<string>> v;  deterministic

cout << e.get();
}
}

Taste of C++11
reverse( begin(s), end(s) ); asynchrony
return s;
}  201x’s best friend
int main() {


cout << e.get();
}
}

Taste of C++11
reverse( begin(s), end(s) ); lambdas
return s;
}  invasion of the functionals
int main() {  capture by ref or by value


cout << e.get();
}
}

Taste of C++11
move semantics
reverse( begin(s), end(s) ); =
return s;  the semantics of value types
} (no pointers! declared lifetime!)
int main() {
+
vector<future<string>> v; // <-- look ma, no *  the efficiency of reference
types (no deep copying!)

cout << e.get();
}
}

Taste of C++11
return s;
}

int main() {


cout << e.get(); Hello, Lang.NEXT!
}
}

Taste of C++11
 program is guaranteed to
allocate only three strings
return translate_to_french( move(s) );
}
 high compute / low latency

int main() {


cout << e.get(); Bonjour, Langue.SUIVANTE!
}
}

Summary
 Modern C++ is clean, safe, and fast.
 Strong abstraction: Type-safe OO and generic code for modeling power, without
sacrificing control and efficiency.
 Full control over code and memory: You can always express what you want to do. You
can always control memory and data layout exactly.
 Pay-as-you-go efficiency: No mandatory overheads.

“The going word at Facebook is that ‘reasonably written C++ code just runs fast,’
which underscores the enormous effort spent at optimizing PHP and Java code.
Paradoxically, C++ code is more difficult to write than in other languages, but efficient
code is a lot easier.” – Andrei Alexandrescu

The Future
(2019-????)

Here be dragons:
End of Moore

Register at
academy.eleks.com
before February 15

And may the Force
be with you!

The Renaissance of C

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (15)

Semelhante a The Renaissance of C

Semelhante a The Renaissance of C (20)

Mais de Victor Haydin

Mais de Victor Haydin (12)

The Renaissance of C