Marco Arena - Perché nel 2015 parliamo ancora di C++? | Codemotion Milan 2015

MILAN 21.11.2015 - Marco Arena
Perché nel 2015 parliamo ancora di C++?
Marco Arena - Webshell

Chi sono
• 28 anni, romano, laureato in Ingegneria Informatica
• Da 4+ anni sviluppo software per una Scuderia di F1 italiana
• Nel 2013 ho fondato ++it, la comunità italiana dedicata al C++
https://marcoarena.wordpress.com/
marco@italiancpp.org

++it -> Italian C++ Community
Social e Gruppi di
Discussione
Spazio per i
principianti
Risorse Consigliate
News e
Newsletter Mensile
Offerte di Lavoro
Meetup, Eventi e
Partecipazioni
Piattaforma per
pubblicare articoli
www.italiancpp.org

Riassunto delle puntate precedenti
Anni ’70, Bell Labs: Nasce il C, l‘assembly portabile

Anni ’80, Bell Labs: nasce il C++ e dominerà gli anni ‘90

Anni 2000: il C++ non è la risposta allo sviluppo Web

RETURN C++
A long time ago, on a
compiler far far away…
OF
THE

Top 100 Android Playstore Apps (U.S.)
Non posso pubblicare questi dati!
Puoi trovarli presso la fonte ufficiale (slide 15):
https://github.com/CppCon/CppCon2015/tree/master/Present
ations/What's%20New%20In%20VS2015

11

http://cpp-lang.io/30-years-of-cpp-bjarne-stroustrup/

Segreto #0: È molto polare
Fonte:www.tiobe.com/index.php/content/paperinfo/tpci/index.html
Fonte: http://www.stroustrup.com/applications.html

Segreto #0: È molto popolare
Fonte: http://stackoverflow.com/research/developer-survey-2015

Segreto #1: È compatibile con il C
Realizzatotramitehttp://jibjab.com

Segreto #2: Si preoccupa del passato

“So just as C++ ‘won’ in the 90s because of its own
strengths plus its C compatibility, C++11 is being adopted
because of its own strengths plus its C++98 compatibility.”
Herb Sutter

"Semplificazione tramite aggiunta di complessità"
vector<Foo> v;
for(vector<Foo>::iterator it = v.begin(); it != v.end(); ++it) { // C++98
// use *it
}
for (auto it = begin(v); it != end(v); ++it) { // C++11
// use *it
}
for(const auto& i : v) { // Modern C++
// use i
}

Segreto #3: Non è garbage collected

• Di default il lifetime di oggetti/variabili è scoped ((de)allocazione automatica)
• ~distruttore() = meccanismo di UNDO general-purpose
(e.g. acquisizione/rilascio di risorse – RAII)
{
ifstream file{"hello.txt"};
// ...
} // file.close(); automatico

class widget {
gadget g;
};
void do_work() {
auto x = …;
auto y = …;
}
Finalizzazione Deterministica:
• A prova di eccezione
• Generazione automatica (member-wise)
• In ordine (inverso a quello di definizione)
// fatto in automatico
~widget() {
g.~gadget();
}~y();
~x();

class widget {
gadget g;
};
void do_work() {
auto x = …;
auto y = …;
}
Finalizzazione Deterministica:
• A prova di eccezione
• Generazione automatica (member-wise)
• In ordine (inverso a quello di definizione)

In alcuni casi il Garbage Collector può complicarti la vita, esempi:
• Sistemi latency-critical (e.g. non vuoi che il GC salti fuori senza controllo)
• Il rilascio di risorse dev’essere deterministico (e.g. files & threads)
http://samsaffron.com/archive/2011/10/28/in-
managed-code-we-trust-our-recent-battles-with-
the-net-garbage-collector
Una storia vera:
Stack Overflow vs .NET Garbage Collector

Segreto #4: È indipendente dal paradigma
Il miglior combattente non è un pugile, un
karateka o un judoka. Il miglior combattente è
qualcuno che si può adattare a qualsiasi stile
di combattimento.
Bruce Lee

void rotate_and_draw(vector<Shape*>& vs, int r)
{
for_each(vs.begin(), vs.end(), [](Shape* p) {
p->rotate(r);
});
for (Shape* p : vs)
p->draw();
}

void rotate_and_draw(vector<Shape*>& vs, int r)
{
for_each(vs.begin(), vs.end(), [](Shape* p) {
p->rotate(r);
});
for (Shape* p : vs)
p->draw();
}
Object-Oriented
Generic Funzionale
(una specie )
Procedurale

int sum = accumulate(
ints(1)
| transform([](int i){ return i*i; })
| take(10)
, 0);
Fonte (range V3 di Eric Niebler): https://ericniebler.github.io/range-v3/

Fonte: http://www.agileday.it/front/sessioni-2014/#iop_vs_oop
public void CatchExceptions_IF()
{
var promocode = new PromocodeStatusIF();
try
{
promocode.Apply("g128g7d2g");
}
catch (AlreadyUsedPromocodeException)
{
Assert.Pass("Already used");
}
catch (ExpiredPromocodeException)
{
Assert.Pass("Expired");
}
catch (NotValidPromocodeException)
{
Assert.Pass("Not valid");
}
Assert.Fail("no exception");
}
public void RemoveCatchExceptionsAndUseMessages_NOIF()
{
var promocode = new PromocodeStatus();
promocode
.AlreadyUsed(() = > Assert.Pass("Already used"))
.Expired(() = > Assert.Pass("Expired"))
.NotValid(() = > Assert.Pass("Not valid"))
.Apply("g128g7d2g");
Assert.Fail("cannot handle this promocode");
}
int main()
{
PromocodeStatus{}
.AlreadyUsed([] { Assert::Pass("Already used"); })
.Expired([] { Assert::Pass("Expired"); })
.NotValid([] {Assert::Pass("NotValid"); })
.Apply("g128g7d2g");
Assert::Fail("cannot handle this promocode");
}
Bonus: Anti-IF in C#
Fonte: http://www.italiancpp.org/2014/11/23/anti-if-idioms-in-cpp/

// Go
func SomeFuntion()
{
defer func() {
Log("SomeFunction executed")
}
... Anything ...
}
Segreto #4: È indipendente dal paradigma – Go’s defer

// C++
void SomeFuntion()
{
defer d { [] {
Log("SomeFunction executed");
}};
... Anything ...
}
Segreto #4: È indipendente dal paradigma – Go’s defer
Implementazione: http://www.italiancpp.org/2013/07/16/defer-con-raii-lambda/

Segreto #5: È adatto alla Systems Programming

Di default:
• Buone/ottime prestazioni ("You don’t pay, at runtime, for what you don’t use" - 0-overhead principle)
• Allocazione su stack & move semantics
• Finalizzazione deterministica
• Contiguità
• Cross-platform

stackheapstackheap
ptr
ptr
ptr
stack heap
Fonte: http://channel9.msdn.com/Events/Build/2014/2-661
Segreto #5: È adatto alla Systems Programming - Contiguità

Cross-Platform: C++ come denominatore comune
• Riuso
• Performance
• Sicurezza

Di default:
• Buone/ottime prestazioni ("You don’t pay, at runtime, for what you don’t use" - 0-overhead principle)
• Allocazione su stack & move semantics
• Finalizzazione deterministica
• Contiguità
• Cross-platform
Se serve, controllo efficiente e completo di:
• Lifetime dei tuoi oggetti (copy, move, …)
• Hardware e risorse del SO (non sempre portabile)
• Data Layout (PODs, …)
• Program size
• In generale: "Fine tuning"

Segreto #6: Sta crescendo in fretta

L’evoluzione non si ferma al linguaggio:
•Compilatori (VC++, Clang, GCC, …)
•Tools (VAssistX, Clang Refactoring, …)
•Librerie (boost, POCO, Qt, …)
•Risorse (Stroustrup, Meyers, …)
•…
Segreto #6: Sta crescendo in fretta

Il C++ è complicato?

No.

Il C++ è molto complicato.

Il C++ è molto complicato

Troppo spesso viene "aperto il cofano" quando non serve

Non è un linguaggio che si impara su Stack Overflow

C++11
language
C# 3.0 (2008)
Java 7 (2011)
C++11
library
Fonte: http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/C-11-VC-11-and-Beyond

WG21
Fonte: http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/C-11-VC-11-and-Beyond

Standardizzare tutto quello che il C++ si è perso negli ultimi 10 anni
(Concorrenza, Parallelismo, Networking, Reflection, …)
Migliorare/arricchire/uniformare aspetti e strumenti propri del linguaggio
(Concepts, Moduli, Ranges, …)
Promuovere e «formalizzare»la diffusione di Guidelines sul «buon» C++
(https://github.com/isocpp/CppCoreGuidelines)
Cosa ci riserva il futuro?

Segreto #7: Ha un ecosistema straordinario
++it Meetup Bologna (Novembre 2014)
CppCon 2014 (Settembre 2014)

isocpp.org
cppcon.org

Quindi perché nel 2015 parliamo ancora di C++?

È molto popolare
È compatibile con il C
Si preoccupa del passato
Non è garbage collected
È indipendente dal paradigma
È adatto alla Systems Programming
Sta crescendo in fretta
Ha un ecosistema straordinario

A general-purpose programming language with a bias towards
systems programming that is:
• a better C
• supports data abstraction
• supports object-oriented programming
• supports generic programming
It is defined by an ISO standard, offers stability over decades, and has a
large and lively user community.
Bonus: Cos’è il C++?
Bjarne Stroustrup
http://www.stroustrup.com/bs_faq.html#what-is

Leave your feedback on Joind.in!
https://m.joind.in/event/codemotion-milan-2015

Domande?
Scrivimi a marco@italiancpp.org

Grazie!

Marco Arena - Perché nel 2015 parliamo ancora di C++? | Codemotion Milan 2015

Recommended

Recommended

More Related Content

Similar to Marco Arena - Perché nel 2015 parliamo ancora di C++? | Codemotion Milan 2015

Similar to Marco Arena - Perché nel 2015 parliamo ancora di C++? | Codemotion Milan 2015 (20)

More from Codemotion

More from Codemotion (20)

Marco Arena - Perché nel 2015 parliamo ancora di C++? | Codemotion Milan 2015