Blog

News, Technik, Entwicklung, Tutorials & mehr!

Bewertung: 5 / 5

Stern aktivStern aktivStern aktivStern aktivStern aktiv

Reaktive Systeme sind Computersysteme die kontinuierlich auf ihre Umgebung reagieren. Der in diesem Zusammenhang geprägte Begriff des Aktorenmodells wurde erstmals in den frühen 1970er Jahren von Carl Hewitt verwendet. Sein mathematisches Model beschreibt ein universales Verfahren zur parallelen Programmierung.  Er war seiner Zeit weit voraus, da zu diesem Zeitpunkt die Rechner noch nicht leistungsfähig genug waren. Das Modell wurde erstmals 1987 in der Programmiersprache Erlang von Ericsson verwendet. Durch den Einsatz der Technologie konnte Ericsson einen Switch mit einer Zuverlässigkeit von 99,999999999% bauen. Dies entspricht einer Ausfallzeit von unter 0.65 Sekunden in 20 Jahren. In den nachfolgenden Jahrzehnten stieg die Leistung der Computer immer weiter an. Anfang des neuen Jahrtausends erreichten die Prozessoren mit den eingesetzten Materialien ihre maximale Taktfrequenz. Prozessorhersteller, wie Intel und AMD, bauten fortan Prozessoren mit mehreren Prozessorkernen bei gleichbleibender Taktfrequenz. Einerseits kann die Hitzeentwicklung bei noch höheren Taktraten mit herkömmlichen Mitteln nicht mehr bewältigt werden. Andererseits kommt es bei immer kleineren Transistoren zu quantenmechanischen Seiteneffekten. Heute erhöhen die Hersteller die Anzahl der Kerne pro CPU, um dennoch eine Leistungssteigerung der CPUs zu erreichen. Dadurch steigt die Relevanz von paralleler Programmierung, da die Berechnung der Algorithmen auf mehrere CPU-Kerne verteilt werden muss. Die Entwicklung von Software mit mehreren Threads, oder über mehrere Rechner hinweg, ist für Entwickler mit vielen Problemen verbunden und kompliziert. Dies ist unter anderem auf die Speicherverwaltung der Threads und Prozesse zurückzuführen. Als Folge entstehen in den letzten Jahren immer mehr reaktive Frameworks für moderne Programmiersprachen, wie zum Beispiel akka für Scala und Java. Reaktive Frameworks bieten dem Entwickler aber weitaus mehr, als nur einfache Parallelisierung über mehrere Prozesse und physikalische Knoten. Mithilfe der Frameworks lassen sich hochskalierbare, fehlertolerante Systeme entwerfen. In diesem Blogbeitrag, wollen wir das Aktorenmodell genauer betrachten.


Der Entwurf von nebenläufigen Anwendungen stellt seit Jahren eine Herausforderung dar, für die es keine einfache Lösung gibt. Das Aktorenmodell stellt eine erprobte und vergleichsweise einfache Weise dar, nebenläufige Algorithmen umzusetzen. Das Aktorenmodell ist ein Architekturmuster, dass auf Basis von Nachrichtenaustausch (=Message Passing) eine verteilte Applikation ermöglicht, ohne dabei einen geteilten Zustand (=Shared State) mit mehren Aktoren zu benötigen. Das Aktorenmodell ist vielfach implementiert, teils in funktionalen Sprachen wie Erlang, teils als Frameworks wie akka oder libcppa. Ein Aktor ist ein leichtgewichtiger und autonomer Prozess. Dem Aktor können Nachrichten geschickt werden, für die er ein eigenes Verhalten bereit hält, welches sich zur Laufzeit in der Regel nicht verändert. Ein Aktor arbeitet dabei immer nur eine Nachricht gleichzeitig ab. Das Aktormodell ist nicht an spezielle Datenstrukturen gebunden, sodass Aktoren lose gekoppelt untereinander kommunizieren können. Leichtgewichtig ist ein Aktor, da er kein eigenen Prozess besitzt, sondern zum Verarbeiten einer Nachricht einen Prozess zugewiesen bekommt. Aktoren nutzen die verfügbaren Ressourcen eines Threads optimal aus und blockieren die Verarbeitung nicht. 

Aktorenmodell Actors akka

Die Abbildung zeigt ein beispielhaftes Netz von Aktoren. Jeder Aktor hat seine eigene Mailbox und einen isolierten Zustand. Basierend auf seinem definierten Verhalten antwortet der Aktor mit dem versenden einer eigenen Nachricht oder erstellt eigene Aktoren und ändert sein zukünftiges Verhalten. Zusammengefasst definiert sich ein Aktorsystem durch folgende Eigenschaften:

  • Ein Aktor kann andere Aktoren erschaffen und mit ihnen kommunizieren.
  • Jeder Aktor hat einen eindeutigen Namen, der als Adresse bei der Kommunikation verwendet werden kann. (in akka)
  • Die Kommunikation zwischen Aktoren basiert auf dem Senden von asynchronen, unveränderbaren (=immutable) Nachrichten an andere Aktoren.
  • Die Nachrichten werden zur Verarbeitung in einer Mailbox gepuffert. Sie ist eine Queue mit n Produzenten (Senderaktor) und einem Konsumenten (Empfängeraktor)
  • Abhängig von der Reihenfolge, den Prioritäten oder dem internen Zustand werden die Nachrichten mittels Pattern Matching von internen Funktionen verarbeitet, die die Ergebnisse ihrerseits wieder als Nachrichten versenden. 

Akka bildet das Aktorenmodell als Framework für die JVM ab. Es wird häufig in den Programmiersprachen Scala und Java verwendet und wurde erstmals im Juli 2009 bei GitHub von Jonas Bonér veröffentlicht. Ein Aktor ist in akka die kleinste Einheit im System und übernimmt in der Regel eine bestimmte Aufgabe. Dabei kann der Aktor seinen Zustand, und damit das Verhalten beim Eintreffen bei weiteren Nachrichten, verändern. Der Zustand eines Aktors wird durch die Werte seiner Variablen definiert. Diese Werte können ausschließlich durch eingehende Nachrichten anderer Aktoren geändert werden. Da es keine gemeinsamen Speicherbereiche mit anderen Aktoren gibt, ist gewährleistet, dass der Zustand eines Aktors nicht durch Zugriffe von außen manipuliert werden kann. Sollte ein Aktor durch einen Fehler zum Absturz gebracht werden, kann der Supervisor, also der Erzeuger des Aktors, den Aktor neu initialisieren und wiederherstellen. Das Verhalten eines Aktors bezeichnet die Logik die beim Eintreffen einer Nachricht ausgeführt wird. Die Logik kann jederzeit als Reaktion auf eine Nachricht verändert werden. Jeder Aktor hat genau eine Mailbox für den Empfang von Nachrichten. Die Mailbox ist standardmäßig eine First In – First Out (FiFo) Queue. Die Queue der Mailbox kann in akka so konfiguriert werden, dass bestimmte Nachrichten priorisiert bearbeitet werden. Auch die Größe der Queue ist frei definierbar.   

akka bietet noch viele weiter Vorteile, die in vielen verschiedenen Blogbeiträgen im Internet und in einschlägigen Büchern beschrieben werden. Dazu zählen unter anderem der Remotezugriff oder das Clustering. Diese Fähigkeiten, macht akka zu einem hervorragendem Framework für moderne Microservices. Häufig findet man akka im sogenannten SMACK Stack wieder - SMACK steht hierbei für Spark, Mesos, akka, Cassandra, Kafka. Dieser Stack ist die Basis für unser Fast Data System bei croGoDeal.


Reaktive Programmierung ist aktuell wie nie zuvor. Der Begriff ist allerdings nicht genau definiert. Somit bezeichnen sich viele Applikationen als reaktiv, die es gar nicht sind. Reaktive Programmierung wird häufig mehr als Buzzword für eine spezielle Art von asynchrone Programmierung verwendet. Die vermutlich am besten passende Beschreibung einer reaktiven Architektur liefert das Reactivo Manifesto. Das möglichst einfache Erreichen der Ziele des Reactivo Manifestos verfolgen diverse Frameworks. Eines der besten für Java und Scala ist derzeit akka. Es ist mit verhältnismäßig einfachen Mitteln möglich antwortbereite, widerstandsfähige, elastische und nachrichtenorientierte Systeme auf Basis der JVM zu implementieren. Ein Java oder Scala Softwarearchitekt für skalierbare Applikationen sollte sich unbedingt erweiterte Kenntnisse in akka aneignen und das Framework in seine Planung mit einbeziehen.   

Bewertung: 5 / 5

Stern aktivStern aktivStern aktivStern aktivStern aktiv

Heute haben wir ein neues Projekt auf der github Seite von innFactory und auf dem npm innFactory Account veröffentlicht. Mithilfe von „react-native-aws-mobile-analytics“ lässt sich AWS Mobile Analytics kinderleicht in react-native Apps integrieren. 

Das SDK wurde von Anton für unsere croGoDeal App in Anlehnung an das originale AWS Mobile Analytics JS SDK entwickelt und jetzt OpenSource veröffentlicht. Der Einstieg sollte auch für neue Entwickler sehr einfach sein. Bei Fragen und Problemen stehen wir euch natürlich über den Issue-Tracker in github zur Verfügung. 

SDK in croGoDeal

Wie bereits erwähnt verwenden wir das SDK selbst für die Analyse und das UI/UX Tracking unserer User in croGoDeal. Neben den gängigen KPI wie "Daily Active User" oder "Monthly Users", können wir mit AWS Mobile Analytics auch A/B Tests und UI/UX Tests über das Toolkit auswerten. Die Tests sind für unsere croGoDeal App und die Strategie der Softwareentwicklung sehr wichtig, damit wir in unsere Hypothesen aus unseren Minimal Viable Products (MVP - Lean Startup) schnell verifizieren oder falsifizieren können. Eine ausführliche Studie, ob sich der geplante Nutzen so eingestellt hat wie erhofft, veröffentlichen wir zu einem späteren Zeitpunkt nach den ersten paar Releases der App.

Projekt auf github:

https://github.com/innFactory/react-native-aws-mobile-analytics

 

Komplettes Beispiel:

https://github.com/innFactory/react-native-aws-mobile-analytics-demo

 

NPM Package:

https://www.npmjs.com/package/react-native-aws-mobile-analytics

 

Bewertung: 5 / 5

Stern aktivStern aktivStern aktivStern aktivStern aktiv

 

Hintergrund: Das Backend unserer Produktidee „croGoDeal“ basiert in Teilen auf dem serverless Framework und Amazon Web Services (AWS). Wir nutzen hinter dem API Gateway eine AWS Lambda Funktion, die als GraphQL Schnittstelle dient. Die komplette Nutzerverwaltung wird mit dem AWS Dienst Cognito abgebildet. Damit wir die Schnittstellen in den einzelnen Entwicklungsstufen hinter dem API Gateway testen können, ohne, dass wir die Autorisierung ausbauen müssen, haben wir ein Desktoptool mit Electron entwickelt, dass uns JSON Web Tokens (JWT) generiert. 

  

Funktionsweise 

Der Screenshot zeigt die Funktionen der Applikation. Als Input sind lediglich der Cognito UserPool, die ClientId sowie die Benutzeranmeldedaten nötig. Der Token wird nach der Anmeldung rechts angezeigt und kann in ein anderes Entwicklungswerkzeug kopiert werden. Um nicht bei jedem Start die Daten eingeben zu müssen, werden die Einstellungen im Anwendungskontext persistent gespeichert. 

Technologien 

Die Anwendung wurde komplett mit der JavaScript-Bibliothek React programmiert, mit der man normalerweise Single Page Applikationen entwickelt. Um eine React App auf einem Desktop-PC nutzen zu können, verwenden wir das Framework „Electron“.

Electron liefert unsere React-App mit Hilfe von Chromium und Node.js als Desktopapplikation aus. 

Für die Anbindung zum AWS Cognito Service verwenden wir das offizielle aws-sdk für JavaScript. 

AWS Cognito Token Generator Software Architektur

 

Die Datenhaltung und Zustandsänderungen in der Anwendung werden durch Redux nach der Flux-Architektur umgesetzt.  Damit die Eingabedaten persistent erhalten bleiben, werden sie via Key-Value Paaren in den JSON-Storage geschrieben. Dies übernimmt immer der jeweilige Redux-Reducer bevor er den neuen Zustand zurückgibt: 

// user reducer 

export default function user(state: any = {}, action: actionType) { 
  switch (action.type) { 
    case SET_USER: 

      if (!action.data.rememberPassword) { 
        delete action.data["password"]; 
      } 

      // save user state persistently 
      storage.set("user", action.data, (err) => { if (err) { console.log(err) } }) 
      return action.data 

    default: 
      return state; 
  } 

Bei diesem Vorgehen muss man bedenken, dass jede State-Änderung auch einen Schreibzugriff auf die Festplatte mit sich zieht. Sobald man eine App mit sehr vielen State-Änderungen und evtl. großen Objekten entwickelt, sollte man besser auf eine periodische Datenspeicherung zurückgreifen, so wie es auch das Framework redux-persist macht. 

Der Sourcecode des Projekts ist OpenSource und auf unserer GitHub Seite verfügbar. 

 

https://github.com/innFactory/aws-session-token-gui  

Bewertung: 5 / 5

Stern aktivStern aktivStern aktivStern aktivStern aktiv

Für unser Produkt innCart benötigten wir eine mobile App für Android und iOS. Aufgrund der guten Erfahrungen mit React-Native haben wir uns für dieses Framework entschieden. Da unser Backendservice in Scala programmiert wird, galt es zu evaluieren, ob wir bei der Programmierung auf Scala mit ScalaJS setzen. Dieser Artikel soll das Ergebnis darstellen.

React-Native

Das JavaScript-Framework "React" von Facebook ist neben Angular eines der beliebtesten und spannendsten Frameworks für Webapplikationen, die es derzeit in der JavaScript-Welt gibt.

React bietet mit der Ausprägung "React-Native" auch die Möglichkeit Mobile Apps in JavaScript zu schreiben - und zwar plattformübergreifend! Dies funktioniert in der Praxis so gut, dass zahlreiche Hersteller Ihre Apps mit dieser Technologie umsetzen. Facebook, Instragram, Airbnb oder auch MieterCast sind nur einige der bekannteren Beispiele. Auch die Community rund um React-Native wächst derzeit stark an. Es gibt mittlerweile für fast alle Bedürfnisse Bibliotheken und Beispiele. Und wenn es doch mal zu einem Problem kommt, hilft die React-Native Usergroup in München weiter.

Eigentlich alles super - wäre da nur nicht JavaScript! Mit ES6 hat sich JavaScript zwar wieder ein großes Stück in die richtige Richtung bewegt, aber für größere Projekte wünscht man sich die Vorteile einer typisierten Sprache, auf die nachfolgend noch näher eingegangen wird.

Scala

Als Alternative zu TypeScript haben wir Scala genauer unter die Lupe genommen. Beide Sprachen ermöglichen eine typisierte Entwicklung. Der TypeScript bzw. Scala Sourcecode wird nach JavaScript transcompiliert und ist somit von jedem Browser interpretierbar und in Kombination mit React-Native auch als Smartphone App nutzbar. Wie eingangs erwähnt lassen wir TypeScirpt außen vor und beschäftigen uns nur mit der Frage, ob es für uns Sinn macht, bei der App-Entwicklung in React-Native auf Scala zu setzen oder stattdessen lieber direkt in JavaScript zu entwickeln.

Um Scala-Code nach JavaScript zu übersetzen ist der Transcompiler Scala.js notwendig. Damit man in Scala auch React-Native verwenden kann, haben wir das Framework SRI (Scala React Interface) verwendet. In folgender Grafik wird der Technologie-Stack mit Scala (links) und ohne Scala (rechts) dargestellt:

ScalaJS vs JavaScript React-Native Stack 

Nach einer ausgiebigen Versuchsreihe mit der Verwendung von Scala in Kombination mit React-Native haben sich folgende Vor- und Nachteile herauskristallisiert:

 

Vorteile

Starke Typisierung

Die Unterstützung von Typen, Klassen und Interfaces (bzw. Traits) wirkt sich besonders bei großen Projekten in Form von robusterer und besser wartbarer Software aus. Des Weiteren ist durch die Typisierung eine bessere IDE-Integration möglich, was erheblich zum Komfort bei der Entwicklung beiträgt und ein nicht zu unterschätzender Faktor ist.

Optimierter JavaScript-Code

Der Scala.js-Compiler optimiert den bei der Übersetzung den JavaScript-Output. Dies ergibt in der Regel eine bessere Performance.

Scala als Sprache für Back- und Frontend

Speziell bei innFactory setzen wir für Cloud- und Serveranwendung zunehmend auf Scala. Mit Scala und React-Native könnten wir ein Teil dieses Know-Hows auch in der Frontendentwicklung der mobilen Clients nutzen.

 

Nachteile

Viele Abhängigkeiten

Wie die obige Grafik zeigt, ergeben sich neben React-Native noch zwei zusätzliche Abhängigkeiten, Scala und SRI. Zudem kommen noch externe Bibliotheken hinzu, die für Scala angepasst werden müssen. Bei einer neuen Version von nur einer einzelnen Komponente im Stack kann es zu Konflikten bei den anderen Abhängigkeiten kommen. Das Auffinden von Fehlerquellen ist nur dann leicht gegeben, wenn es sich um eine schlanke Architektur mit nur wenigen externen Bibliotheken handelt. 

Kleine Community

Da die Technologien bisher nur wenige Unterstützer auf github haben, wäre eine Einstellung des Supports ein weitaus größeres Risiko. Abgesehen von Scala.js steckt hinter dem Stack kein professioneller Support, sondern lediglich sehr gute Freizeitprojekte. Vor allem bei SRI besteht hier eine sehr große Unsicherheit, da es nur wenige Entwickler gibt. 

Benötigtes Wissen in beiden Technologien (Scala und React-Native)

Gute Scala-Entwickler sind schwer zu finden. Für React gibt es inzwischen etwas mehr. Aber Programmierer aufzuspüren, die beide Technologien beherrschen ist fast ein Ding der Unmöglichkeit.

Während die Einarbeitungszeit für einen JavaScript-Entwickler in React-Native nur wenige Tage bis Wochen beträgt, erhöht sie sich in Kombination mit Scala auf einige Monate. Für Scala-Programmierer beträgt die Zeit zum Aufbau des Know-Hows nicht ganz so lange, aber auch hier müssen die Konzepte von React, wie z.B. die Redux-Architektur, erstmal verinnerlicht werden.

 

Fazit

Für uns hat Scala einen festen Platz, wenn es um Backend- und Cloudentwicklungen geht. Die Idee mit Scala auch JavaScript zu erzeugen ist sehr spannend. Aber für das anstehende Projekt überwiegen in unserem Fall die Nachteile eindeutig. Der Technologie-Stack ist leider noch zu wackelig. Auch die Aufstockung des Entwicklerteams könnte sich als extrem schwierig erweisen. Allein letzterer Punkt würde für uns als K.O.-Kriterium ausreichen.

Wir finden, dass sich das Scala.js-Projekt in die richtige Richtung bewegt und werden es sehr genau im Auge behalten. Für unsere Produktentwicklung aber, werden wir auf reines React-Native für die App setzen und Scala als primäre Technologie im Backend verwenden.

 

Bewertung: 5 / 5

Stern aktivStern aktivStern aktivStern aktivStern aktiv

 

Der Begriff Cloud Computing ist zurzeit in der Informationstechnik allgegenwärtig. Es gibt viele Interpretationen, aber keine standardisierte oder gar einheitliche Definition. Cloud Computing erlaubt die Bereitstellung und Nutzung von IT-Infrastruktur, von Plattformen und von Anwendungen aller Art als im Web elektronisch verfügbare Dienste. Der Begriff Cloud soll dabei andeuten, dass die Dienste von einem Anbieter im Internet erbracht werden. Obwohl es keine standardisierte, einheitliche Definition für Cloud Computing gibt, sind die grundlegenden Konzepte als auch die generellen Ziele des Cloud Computing unbestritten. Cloud Computing nutzt Virtualisierung und das moderne Web, um Ressourcen verschiedenster Art als elektronisch verfügbare Dienste dynamisch bereitzustellen. Die Dienste sollen dabei von mehreren Konsumenten verlässlich und skalierbar nutzbar sein, d. h. sowohl auf Abruf als auch nach Bedarf verfügbar sein. Aus der Sicht des Cloud-Anbieters impliziert dies in der Regel eine Multi-Mandanten Architektur und ein nutzungsabhängiges Abrechnungsmodell. Das Konzept der Virtualisierung erlaubt eine abstrakte, logische Sicht auf physische Ressourcen und umfasst sowohl Server, Datenspeicher, Netzwerke als auch Software. Die zu Grunde liegende Idee ist, physische Ressourcen in Pools zusammenzufassen und gemeinsam zu verwalten. Nach C. Braun definiert sich Cloud Computing demnach wie folgt: 

 

 

Unter Ausnutzung virtualisierter Rechen- und Speicherressourcen und moderner Web-Technologien stellt Cloud Computing skalierbare, netzwerk-zentrierte, abstrahierte IT-Infrastrukturen, Plattformen und Anwendungen als on-demand Dienste zur Verfügung. Die Abrechnung dieser Dienste erfolgt nutzungsabhängig.

 

Je nach Zugriffsschicht teilt man Cloud Computing in verschiedene Ebenen der Bereitstellung ein. 

Infrastructure as a Service (IaaS)

In der IaaS-Schicht wird den Benutzern eine abstrahierte Sicht auf Hardware angeboten, d. h. auf Rechner, Massenspeicher, Netzwerke etc. Hierfür wird ihm in der Resource Set-Unterschicht eine Benutzerschnittstelle zur Verwaltung einer Menge von Ressourcen bereitgestellt, die ermöglicht, Teile davon für die eigene Verwendung zu allokieren. Typische Funktionalitäten an der Benutzerschnittstelle sind das Anlegen bzw. Beseitigen von Betriebssystem-Abbildern, die Skalierung von beanspruchten Kapazitäten oder die Definition von Netzwerktopologien. Die Schnittstelle bietet darüber hinaus die erforderlichen Funktionalitäten für den operativen Betrieb, wie z. B. das Starten und Stoppen der Betriebssystem-Instanzen.

 

Platform as a Service (PaaS)

Die Cloud-Dienste in der PaaS-Schicht richten sich meist nicht an Endkunden sondern an Entwickler. Es sind Entwicklungs- und Laufzeitumgebungen, in denen sich eigene Software in einer bestimmten Programmiersprache entwickeln bzw. ausführen lässt.

 

Software as a Service (SaaS)

Software-Anwendungen in der Cloud, die den Endkunden direkt adressieren, gehören zur SaaS-Schicht. Auf der Kundenseite entfällt in dieser Klasse die lokale Software-Installation und mithin auch die Bereitstellung der erforderlichen Ressourcen. Aus Perspektive der beschriebenen Cloud-Architektur kann das SaaS Angebot auf Basis eines Angebots in PaaS oder IaaS beim Anbieter entwickelt und betrieben werden. Innerhalb der SaaS-Angebote lässt sich unterscheiden zwischen Anwendungsdiensten, deren Funktionalität im Wesentlichen auf einer einzigen einfachen Anwendung basiert und vollwertigen komplexen Anwendungen. 

 

Lesen Sie auch unseren Artikel zu Cloud Computing beim Blickpunkt Rosenheim

Kategorien

  • News
  • Gastbeiträge
  • Data Science & Engineering
  • Software Engineering
  • innoVation:now

Blogbeiträge

Der Blog!

In unserem Blog erklären wir diverse Technologien, verweisen auf interessante Webcasts und informieren Sie über Neuigkeiten im Umfeld von innFactory und unseren Produkten.