C++

Unsere Hauptprogrammiersprache ist eindeutig C++. Unser Statement dazu:

Wir lieben C++!!!

Was, seid ihr verrückt? Das kann doch nicht euer Ernst sein! C++ ist doch: ... Nein, es ist unser Ernst: wir lieben es, weil C++ einfach super ist!!! 

Es ist eine tolle Mischung von low-level, performance-kritischen, OO, generischen und funktionalen Features! Und es eine der wenigen  Sprachen, wo man beides haben kann: hohes Abstraktionsniveau und eine "Bare Metal" Performace! Von den Sprachen, die ich bisher kenne, hat mich nur die ML-Familie vielleicht noch mehr beeidruckt, also: OCaml, F# (und, ja... auch Haskell).¹

Jaaa, ich weiss, C++ ist nicht ganz ohne Tadel: es ist komplex! Na und? Seien wir ehrlich, welche Programmiersprache ist es nicht?

Wichtiger ist vielleicht, dass es nicht perfekt ist: früher (C++98) dachte ich z.B. dass man mit Templates und Überladen der Operatoren alles machen könnte. Dann hat es sich aber herausgestellt, dass für manche Sachen man einfach doch neue Sprachkonstrukte braucht. 

Aber jetzt sind die da: in den neuen C++11 und C++14 Standards. Es hat sich eine Menge geändert! Als Nächstes möchte ich einge vielleicht unbekannte Fakten über "modernes" C++ vorstellen:

Wie man mit C++ programmieren kann.

Man kann natürlich in dem guten, altbewährten OO-Stil arbeiten. Man kann aber auch (Stand von 2014):

• funktional programmieren:

wie hier: 

 // the Maybe monad:
 template<typename T>
   struct maybe {
   // ....
 };

 // a non-monadic function;
 int foo(int x,int y) {
   return x*y;
 }

 // lift it into the monad:
 auto mfoo = mlift<maybe>(&foo);

 // and work inside the monad!!
 auto res = mfoo(maybe<int>(2), maybe<int>(3)); 
 assert(res == maybe<int>(6));

oder wie hier (FTL), die C++ Standardbibliothek um funktionale Features erweitern:

  // curry a function
  auto plus = ftl::curry(std::plus<int>);
  auto addOne = plus(1);

  // use an applicative
  int algorithm(int, int, int);
  ftl::maybe<int> maybeGetAValue();
  ftl::maybe<int> maybeGetAnother();
  ftl::maybe<int> maybeGetAThird()

  using ftl::operator%; 
  using ftl::operator*;
  auto result =
    ftl::curry(algorithm) % maybeGetAValue() * maybeGetAnother() * maybeGetAThird();

  // stack monads with transformers!
  template<typename T> using listM = ftl::maybeT<std::list<T>>;

Eine weitere Bibliothek findet man z.B. hier, mit einer interessanten Begründung für den Sinn und Zweck der funktionaler Programmierung in C++:

• Man kann DSLs (domänenspezifische Sprachen) entwerfen:

wie zum Beispiel zum Testen:

 using namespace igloo; // the test framework!

 Describe(A_Cell)
 {
   It(should_have_coordinates)
   {
     Cell cell(3,4);
     Assert::That(cell.getX(), Equals(3));
     Assert::That(cell.getY(), Equals(4));
   }

   It(can_detect_if_its_a_neighbour)
   {
     Cell cell(1,5);
     Cell neighb(2,4);
     Assert::That(cell.isNeighbourTo(neighb), IsTrue());
   }
 };

oder um MATLAB zu ersetzen wie hier. Ein Zitat vom Autor der Bibliothek:

• Man kann im generischem Stil programmieren:

#include "Die.h"
#include <iostream>

template<typename DIE> 
class GameFourWinsT 
{
  DIE die;
public:
  void play(std::ostream& out = std::cout) {
    if (die.roll() == 4) {
      out << "You won!\n";
    } 
    else {
      out << "You lost!\n";
    }
  }
};

typedef GameFourWinsT<Die> GameFourWins;
GameFourWinsT game;
game.play();

und damit z.B. Mixins in C++ realisieren.

• Man kann Berechnungen in der Compilierzeit duchführen lassen:

constexpr int multiply (int x, int y)
{
  return x * y;
}

// evaluate this at compile time
const int val = multiply( 10, 10 );

(Es geht auch mit Templates, aber viel schwieriger!)

• Man kann eigene Maßsysteme definieren 

und zwar mit Hilfe von benutzerdefinierten Literalen:

assert(1_kg == 2.2_lb); // Kilos und Pfunde

oder

time t =1.0_s;
speed s1 = 100.0_m / 9.8_s;   // very fast for a human
speed s2 = 1.2_km / 0.5_h;    // slow going
speed s3 = 1.2_km / 30.0_min; // the same speed

// speed s2 = 100 / 9.8s; // compile error

• Man kann im Erlang's "Share-Nothing" Stil programmieren

und zwar mit der libcppa Bibliothek, Erlang-echt mit Pattern Matching und Actors:

// A Generic Asynchronous IPv4 Server: 
template <typename Connection>
void server(uint16_t port, char const* addr, actor_ptr handler) 
{
  auto acceptor = network::ipv4_acceptor::create(port, addr);

  receive_loop 
  ( 
    // libcppa's blocking API
    on(atom("accept")) >> [&] 
    {
      if (util::poll(acceptor->file_handle()) &&
         (auto io = acceptor->try_accept_connection())) 
      {
        auto conn = spawn<Connection>((*io).first, (*io).second);
        send(handler, atom("connection"), conn);
      }
      self << last_dequeued();
    },
    on(atom("kill")) >> [] { self->quit(); }
  );
}

• Man kann aus einer Datenbeschreibung Code für Senden/Empafgen von Protokollpaketen einfach generieren

z.B. mit einer Mischung aus Laufzeit- und Template- Metaprogrammierung mit der Boost Fusion Bibliothek:

BOOST_FUSION_DEFINE_STRUCT(
 (example), header,
 (example::magic_t, magic)
 (example::version_t, version)
 (uint32_t, length)
 (std::unordered_map, hdr_props)
 (example::msg_type_t, msg_type)
 (std::vector, vals)
)

Ähnliches ginge wohhl auch mit Boost Hana!

Übrigens, wussten Sie schon von Online C++ Compilern? Und von den Dependency-Injection Lösungen, oder von dem "Modernizer", und dem Address- oder Thread-"Sanitizern", oder vielleicht vom ACF Komponenten Framework, und, und, und...

Was man mit C++ programmieren kann.

Sie wissen es bestimmt dass man C++ folgendes sehr gut erstellen kann:

• Multithreading Applikationen, Systemprogrammierung, Compiler, Interpteter und JIT-Compiler (z.B. bei Facebook)
• portable GUIs (mit Qt auf Windows, Linux, Mac, Android),
• Embedded und Real-Time Systeme (um z.B. auf dem Mars Auto zu fahren),
• Grafik, Bildverarbeitung, Mustererkennung (z.B. Gesichter)

obwohl mann nicht:

• Linux Kernel Code damit schreiben kann (da hat Linus was dagegen!)

Aber wussten sie auch dass folgende Sachen (Stand von 2014) auch gehen?

• Browser-Applikationen:
  

Man kann seine Anwendung in C++ erstellen und mit Emscripten in Javascript übersetzen, dann läuft es in jedem Browser! Lesen Sie hier über "Emscripten & asm.js: C++'s role in the modern web". Ein Zitat vom Autor:

D.h. sogar Gaming-Engines kann man damit in den Browser portieren!

• Web-GUIs:
  

Um eine GUI für ihr gerande mit Emscripten portiertes Programm zu ertellen könnten sie auf Javascript zurückgreien, oder aber es in C++ zu schreiben - es gibt einen Qt-Port auf Emscripten! 

Gut, könte ein Overkill sein... Oder, man nimmt den Duetto-Compiler (jetzt wohl zu Cheerp umbennant), schreibt sowohl Client und Server Code in C++, un lässt es mit für den Browser und den Server übersetzen. Man kann es dann sogar direkt im Browser debuggen²! Zitat:

• traditionelle Web-Applikationen auf dem Server (in Java-Manier):
  

Dafür gibt es eine Reihe von Frameworks (wie CppCMS, Wt, Treefrog usw.). Ich habe früher ein wenig darüber geschrieben, aber neuerdings gibt es eine deutschsprachige Seite, die sich ausschliesslich mit diesem Thema befasst.

• portable mobile Apps

Lesen Sie wie man das bei Dropbox macht, warum C++ dafür wie geschaffen ist, und warum man manchmal so ein Framework selber schreiben soll. Die häufigste Wahl ist allerdings Marmalade - viele Games wurden damnit gemacht. Und zwar komplizierte wie: "Lara Croft and the Guardian of Light" und "Call of Duty: World at War Zombies", aber auch kleinere wie "Doodle Jump".

• REST-Clients und Mashup Servers für REST-full Cloud-Services

mit Microsoft's Casablanca REST-Framework! Damit kann man entweder die Cloud-Services konsumieren (wie hier), oder abfragen und in einen neuen Service kombinieren (eben ein Mash-Up erstellen - schauen Sie sich z.B. den Code hier)!

• hochperformante verteilte Applikationen

Aber, das wussten Sie wahrscheinlich schon. Trotzdem kann man sich hier zwichem dem schon erwähntem Actor-Stil (mit der libcppa Bibliothek) oder dem P2P Stil entscheiden, wie z.B. hier, mit der RTI Connext Bibliothek. Ein Zitat vom Autor der letzteren scheint hier angebracht zu sein als eine Art Zusammenfassung:

--

1. Na gut, Lisp ist auch nicht schlecht, aber wenn man im OCaml gesehen hat, dass es auch ohne Klammern geht, dann denkt man sich: sind die Macros wirklich so toll? Aber wir schweifen ab.
2. Zitat: "Cheerp fully supports the SourceMaps standard, which makes it possible to debug your original C++ code directly in the browser. Set break points, step the execution and see the original C++ code when an exception happens."
3. Erlang ist die Vorzeigesprache für fehlertolerante, verteile Systeme, sein Motto: "Build massively scalable soft real-time systems" .