All Posts By

Herbert Dowalil

Artikel JavaSpektrum: Pest Control – Immerwährende Immunität für Java-Code

By | Artikel, Publikationen | No Comments
Immerwährende Immunität für Java-Code

JavaSPEKTRUM Logo

„Pest Control – Immerwährende Immunität für Java-Code“
Autor: Herbert Dowalil
Artikel im JavaSPEKTRUM 06/2018
erschienen am 30. November 2018

Wie schön wäre doch das Leben eines Softwareentwicklers, wenn da nicht die lästigen Wanzen, genannt Bugs, wären, die sich immer wieder ungefragt in unserem Code breitmachen. Warum sind einige Systeme wesentlich weniger anfällig für Bugs als andere? Tatsächlich ist es möglich, durch Anwendung mancher Designprinzipien, Software schon im Zuge der Erstellung gezielt robust zu gestalten.

Eine Garantie, dass keine Fehler mehr gemacht werden, kann und wird es natürlich nie geben. Tatsache ist aber auch, dass man durch manch einfache Maßnahme die Robustheit von Software spürbar verbessern kann. Darüber hinaus können die in diesem Artikel angeführten Maßnahmen auch einen ersten Schritt zu einer langlebigen Softwarearchitektur bedeuten. Mich hat die Erfahrung gelehrt, dass sich eine solche am besten bottom-up im Laufe der Evolution der Software entwickelt. Dies funktioniert dann auch klar besser als ein Big Up Front Design eines zentralen Architekturteams.

Digitale Ausgabe JavaSPEKTRUM

 
follow us on Twitter – @embarced

Architektur Meetup Wien

Softwarearchitektur Meetup Wien: Evolutionäre-Architektur & Digitalisierung

By | Allgemein, Publikationen, Vorträge | No Comments
Meetup
 Evolutionäre-Architektur & Softwarearchitektur/Digitalisierung
Impuls und Moderation: Stefan Toth & Herbert Dowalil
Veranstaltung beim Softwarearchitektur Meetup Wien
05. November 2018, 18:00 Uhr
weXelerate, Praterstrasse 1 in Wien

Foliendownload (PDF)

Evolutionäre Architekturansätze können helfen, sich kleinteiliger und stetiger um Innovation zu kümmern und auch mit größeren Systemen über längere Zeit hohe Qualität auszustrahlen. Sie werden mehr und mehr der neue Standard – das neue Normal.

Beim neuen Softwarearchitektur Meetup gestern Abend in Wien gab Stefan Toth einen Überblick, welche Faktoren Softwarearchitektur heutzutage erfolgreich machen, um in einem dynamischen Umfeld zu bestehen. Er stellte den Zyklus evolutionärer Architekturentwicklung vor – von Lernfenstern mit Experimenten und erlaubten Abweichungen vom „Standard“, über weich definierte Regeln und geförderte Innovation bis hin zur eingeschränkten Anwendbarkeit von überholten Konzepten. Dabei spielen aktuelle Konzepte wie Anti-Zähigkeit und Fitness-Functions eine zentrale Rolle. Praxisbeispiele aus realen Entwicklungsvorhaben verdeutlichen die Ansätze. Fast 60 Teilnehmer waren beim Kickoff des Wiener Meetups in den Räumen von weXelerate dabei und es gab einen regen Austausch zwischen Speakern, Besuchern und Organisatoren!

Stefan Toth - Softwarearchitektur Meetup Wien: Evolutionäre-Architektur

Unser nächstes Meetup ist für den 12. Dezember 2018 geplant – wir freuen uns auf den Austausch in Vorträgen, Diskussionen und interaktiven Formaten!

Fotos vom Softwarearchitektur Meetup am 05. November 2018:

Bullshit_Bingo_Artikel JAXenter

Artikel auf JAXenter – Hohle Phrasen in der IT erkennen und vermeiden

By | Artikel, Inhaltliches, Publikationen | No Comments
Bullshit Bingo: Wie man hohle Phrasen in der IT erkennt und vermeidet

JAXenter Logo

Bullshit Bingo: Wie man hohle Phrasen in der IT erkennt und vermeidet
Autor: Herbert Dowalil
Online-Beitrag bei JAXenter, erschienen am 19. Oktober 2018

Online lesen auf JAXenter

Jeder kennt ihn, jeder belächelt ihn und jeder benutzt ihn hin und wieder mal als Werkzeug, um unverdient zu Glänzen: Den Bullshit. Er ist in unserer Branche so omnipräsent, dass er eigentlich kaum noch wegzudenken ist. Es muss die Frage erlaubt sein, worum es sich dabei eigentlich handelt und warum gerade wir in der IT so massiv darunter zu leiden haben.

Online lesen

 
follow us on Twitter – @embarced

HD_DZone_Visibility Metrics

DZone Article – Visibility Metrics and the Importance of Hiding Things

By | Artikel, Publikationen | No Comments
Visibility Metrics and the Importance of Hiding Things

DZone

Why is it important to hide the things a module contains from its consumers in microservice architecture? Hiding things is important when designing a sustainable architecture. There are a couple of ways to hide internal structures and design decisions from the outside world and from the consumers of a modules API. These days, microservices are very popular. The microservice community argues, that distribution over the network is the one and only way to actually hide the internals of modules (here services). We just need to take a quick look at good old Java, where we already have plenty of options for hiding, even without using tools or proprietary libraries.

Controlling this by using metrics and maybe even tool support can be crucial for success. Just recently I was wondering, how to measure how well a piece of software is in hiding things. Surprisingly there was no software metric and no tool so far that offered a possibility to measure this. The Visibility Metrics described in the article helped me to solve the problem..

..read more

 
follow us on Twitter – @embarced

Software vermessen_Blog Dowalil

Über die Vermessung von Software

By | Inhaltliches | No Comments


“If you can´t measure it, you can´t manage it”

Das wusste schon Peter Drucker! Wenn sich die Qualität von Software als Zahl wiedergeben lässt, so wird es wesentlich einfacher gute Entscheidungen zu treffen. Aber auch wenn Sie so eine Bürde nicht zu tragen haben, möchten Sie vielleicht wissen, wie weit Sie im Zuge von Verbesserungsmaßnahmen eines Produktes bereits gekommen sind. Es ist also kein Wunder, dass es den Wunsch nach der Objektivierung durch Kennzahlen in der Welt der IT ebenfalls gibt. Zunächst klingt es verlockend, denn so scheint es doch, als würden sich die Bits und Bytes von Software besonders für die Abbildung durch Metriken eignen. Tatsächlich habe ich in meiner Karriere aber sehr oft erleben müssen, dass durch die Anwendung einer Kennzahl mehr Schaden angerichtet wurde, als Nutzen generiert. In diesem Artikel möchte ich Ihnen einerseits Möglichkeiten aufzeigen, Software in Zahlen zu Vermessen, als auch andererseits vor typischen Fallstricken warnen, die es im Zuge dessen zu vermeiden gilt.

Kategorien von Software Metriken
Zyklomatische Komplexität nach McCabe als Beispiel
Mögliche Fallstricke beim Einsatz von Metriken
Mögliche Lösungsansätze beim Umgang mit Metriken

Eingehen möchte ich auf Kennzahlen zur Messung von Komplexität und struktureller Qualität von Software. Tatsächlich gibt es noch weitere Kategorien von Metriken im Umfeld von Software. Bei der folgenden Auflistung beziehe ich mich dabei ausschließlich auf Kennzahlen, welche sich auf das fertige Software-Produkt beziehen, und nicht auf solche, die im Umfeld davon existieren. Es gibt Kennzahlen, welche versuchen die Produktivität bei Entwicklung der Software zu vermessen, oder die Effizienz im Zuge der Benutzung. Dies ist aber nicht Fokus dieses Artikels und ich verweise dafür auf das Buch Software in Zahlen von Harry M. Sneed, Richard Seidl und Manfred Baumgartner.

Kategorien von Software Metriken

Quantität

Dabei wird die schiere Menge an Software gemessen, welche vorhanden ist. Es kann sich um die Anzahl an Codezeilen handeln, die Anzahl an Klassen, Codedateien oder auch Bildschirmmasken, welche vorhanden ist. Der Vorteil dieser Art von Kennzahl ist die Transparenz, da man sich darunter relativ einfach etwas vorstellen kann. Der Nachteil ist, dass es relativ wenig über die Software aussagt. Beim Hauptschirm einer Applikation wie Microsofts Word ist mit Sicherheit das x-fache an Komplexität enthalten, als in einer durchschnittlichen Bildschirmmaske.

Komplexität

Wie schwierig ein Stück Software zu verstehen oder zu entwickeln ist wird wesentlich besser von den Kennzahlen aus dem Gebiet der Komplexität wiedergegeben. Wenn Sie die Wartungs- oder Entwicklungstätigkeiten in Relation setzen möchten, so verwenden Sie bitte besser eine dieser Kennzahlen.

Struktur

Diese Art von Metriken misst die Kapselung des Codes in Bausteine, und auch, wie diese dabei zueinander in Relation stehen. Beispiele dafür wären die Software-Package-Metrics von Robert C. Martin oder auch die Metriken von John Lakos. Ich ziehe dabei diejenigen von John Lakos vor, da diese Abhängigkeiten transitiv betrachten. Eine Abhängigkeit, wo Baustein B den Baustein A benötigt wirkt sich dort nämlich auch auf einen potentiellen Baustein C aus, wenn dieser den Baustein B benützt. Dies entspricht viel mehr der tatsächlichen Natur der Abhängigkeiten im Code.

Testautomatisierung

Die bekannteste Kennzahl aus dem Bereich der automatisierten Tests ist mit Sicherheit die der durch Unit-Tests abgedeckten Code-Zeilen. Testabdeckung wird dabei aber auch durch System- und Integrationstests erzeugt, welche zwar ebenfalls Code automatisch testen, dabei aber nicht die Kennzahl der Abdeckung durch Unit-Tests beeinflussen. Das kann ein guter oder schlechter Aspekt dieser Kennzahl sein. Tatsächlich ist meine Erfahrung, dass eine sehr niedrige Abdeckung durch Unit-Tests ein Indiz für das Fehlen von Strukturen in der Codebasis darstellt. Unit-Tests testen nämlich per definitionem gezielt die einzelnen kleinsten Bausteine des Codes. Wenn dies nicht passiert, so ist es nicht selten so, dass es diese Zerlegung in Bausteine nicht gibt und das Unit-Testen dadurch gar nicht erst möglich ist.

Qualität

Die Erfüllung gewisser Qualitätsmerkmale der laufenden Software kann ebenfalls recht gut auf objektive Art und Weise gemessen werden. Ein Beispiel dafür ist die Zuverlässigkeitsmessung nach Tom Gilb, welche schlichtweg wie folgt errechnet wird:


(Anzahl richtiger Ergebnisse) / (Anzahl aller Ergebnisse)


Andere Beispiele wären die durchschnittliche Zeit bis zum Zusammenbruch des Systems (Mean-Time-to-Failure) und die durchschnittliche Zeit bis sich dieses wieder von seinem Problem erholt (Mean-Time-to-Recover). Eine Messung der durchschnittlichen Response Time würde wiederum die Erfüllung von Performance Anforderungen prüfen.

Zyklomatische Komplexität nach McCabe als Beispiel

Verdeutlichen möchte ich die Thematik noch anhand eines konkreten Beispiels, nämlich der Zyklomatischen Komplexität nach McCabe, da es sich dabei um die populärste der Komplexitätsmetriken handelt. Als Beispiel soll uns das folgende Code-Snippet dienen:


while (x < 100) {                  // 1

   if (values(x) % 2 == 0) {       // 2 
      parity = 0;                  // 3 
   } else {
      parity = 1;                  // 4 
   }                               // 5 

   switch (parity) {               // 6 
   case 0: 
      System.out.pritln("Even");   // 7 
      break; 
   case 1: 
      System.out.println("Odd");   // 8 
      break; 
   default: 
      System.out.println("Weird"); // 9 
      break; 
   } 

   x++;                            // 10 
}
result = true;                     // 11

Diese Abbildung illustriert die möglichen Wege durch dieses relativ kurze Stück Code. Hier sehen wir 11 verschiedene Knoten (welche auch im Code durch Kommentare am Zeilenende markiert sind) sowie 14 Pfeile, welche die möglichen Pfade zwischen dieses Knoten illustrieren. Die Formel lautet nun:


(Anzahl Pfeile) – (Anzahl Knoten) + 2


Was im konkreten Fall eine zyklomatische Komplexität nach McCabe von 5 ergibt.

Bleibt noch die Frage zu beantworten, was man denn nun konkret mit einer solchen Kennzahl wie McCabe anfangen kann?! Eine mögliche Anwendung ist die Beantwortung der Frage, ab wann man einen Baustein (wie eine Klasse) auf Grund seiner Komplexität weiter aufteilen sollte. Ein hohes Maß an Komplexität könnte bedeuten, dass diese eine Klasse mehr als nur eine Verantwortung hat, was aber im Sinne des Single-Responsibility-Prinzips nicht sein sollte. Außerdem ist eine derart komplexe Klasse auch für den Entwickler schwieriger zu verstehen, und sollte daher eher auf weitere Einzelteile aufgebrochen werden. Es ist demnach durchaus sinnvoll, eine Obergrenze für Komplexität für Klassen oder Methoden festzulegen.

Mögliche Probleme beim Einsatz von Software Metriken

Leider gibt es jede Menge Fallstricke, welche es auf dem Weg zum erfolgreichen Einsatz von Metriken im Unternehmen zu vermeiden gilt. Die am häufigsten anzutreffenden sind:

Einschränkende Sicht auf die Gesamtproblematik

Eine Kennzahl ist eine numerische Abstraktion eines Aspektes einer Software. Die Gefahr beim Messen einer solchen ist, dass daraufhin dieser Aspekt maximiert wird, und dadurch nicht erfasste Aspekte vernachlässigt werden. Ein Beispiel dafür: Ein Unternehmen war ausgesprochen unglücklich über die hohen Kosten, welche vom Rechenzentrum für CPU Zeiten berechnet wurden, welche am Großrechner anfielen. Ergo gab man das Ziel aus, die CPU Nutzung am Großrechner messbar zu reduzieren. Als möglicher Verursacher wurde die Kompilierung von Cobol Sourcen ausgemacht. Auf die Aufforderung, die Sourcen in Zukunft auf alternativer Hardware zu übersetzen und erst danach auf den Großrechner zu übertragen, konnte das Development Team aufzeigen, dass die Kosten für die Mehraufwände die möglichen Ersparnisse durch die Reduktion der CPU-Zeiten überstiegen hätten.

Auf Umwegen zum Ziel

Viele Wege führen nach Rom. Ähnliches gilt für die Erfüllung von Kennzahlen. Meist möchte man, dass mit der gewünschten Veränderung einer Kennzahl auch eine gewünschte Veränderung im Unternehmen stattfindet. Allerdings wird dieses eigentliche Ziel dabei oft nicht erreicht, einfach weil übersehen wird, dass ein für die Mitarbeiter angenehmerer Weg ebenfalls zum gewünschten Ziel führt. Im schlimmsten Fall kann genau das sogar zu einer Verschlechterung der Situation führen. Das klassische Beispiel um dies darzustellen ist die folgende Geschichte, die sich so angeblich in Indien zugetragen hat, als es noch von den Briten besetzt war: Ein Gouverneur wollte die Anzahl der Kobras in seinem Herrschaftsgebiet reduzieren, indem er ein Kopfgeld für jede tote Kobra ausbezahlte. Das Ergebnis war aber, dass sich die bestehende Kobra-Plage in der Gegend sogar noch verschlimmerte. Durch das Kopfgeld erhielten tote Kobras plötzlich einen Wert. Was dazu führte, dass die Einwohner begannen, Kobras zu züchten und später zu töten, um diese Prämie zu kassieren. Manche dieser Tiere entkamen und verschlimmerten dadurch sogar die Problematik.

Ein Beispiel aus der IT Praxis ist die folgende Anekdote: Ein Konzern wollte von einem der großen Consultingunternehmen ob der Produktivität seiner Programmierer bescheid wissen. Das Unternehmen untersuchte die beiden Teams, von denen eines für die Erstellung und Wartung von Cobol Sourcen verantwortlich war, und das andere entsprechend für den Java Code. Das Ergebnis dieser Untersuchung war: Man sollte auf Cobol Entwicklung umsteigen, weil dieses Team angeblich wesentlich produktiver wäre. Was war hier geschehen? Gemessen wurde die Anzahl an Codezeilen in Relation zu den Stunden, welche die Mitarbeiter zur Programmierung dessen brauchten. Da derselbe Sachverhalt in Java allerdings in wesentlich weniger Codezeilen ausgedrückt werden kann, war man danach irrtümlich der Meinung, dass Cobol Entwicklung produktiver wäre.

Falsche Anreize

Verschärft wird jede Art von Problemen mit Kennzahlen immer, wenn an der Erfüllung eines gewissen Grenzwertes der Erfolg von Mitarbeitern gemessen wird. Ganz besonders dann, wenn damit ein monetärer Anreiz verbunden ist. Überlegen Sie sich also gut, ob sie eine finanzielle Belohnung im Umgang mit Metriken einsetzen möchten.

Mögliche Lösungsansätze

Ich hoffe ich konnte Sie überzeugen, dass beim Einsatz von Metriken zur Vermessung von Software auf jeden Fall Vorsicht geboten ist. Nachdem Sie nun aber genug über Probleme gelesen haben, möchte ich nun zu möglichen Lösungsstrategien zur Thematik kommen. Was empfiehlt sich, um mit Metriken auch tatsächlich erfolgreich zu sein?

Wenig reduzierend

Den Terminus “gesamtheitlich” vermeidend möchte ich empfehlen, Kennzahlen zu wählen, welche bei der Auswahl der Aspekte des Erfolges möglichst wenig einschränkend sind. Also so breit wie möglich die Güte der Arbeit der Mitarbeiter wiedergeben. Dadurch wird vermieden, dass nur ein Aspekt besonders betont wird und somit falsche Prioritäten gesetzt werden. Dies hat wiederum den Nachteil, dass es somit u.U. schwierig wird, die Performance einzelner Teams einzuschätzen. Entschärfen können Sie diese Problematik wiederum durch eine Organisation um die fachlichen Teilbereiche der Problemdomäne herum. Ein Team ist dann genau der Behandlung einer Subdomäne (oder Business Capability) zugeordnet und dafür verantwortlich. Anhand dessen kann der Erfolg prinzipiell recht umfangreich, aber eben nur für einen solchen Teilbereich, gemessen werden. Wesentlich schwieriger is so etwas, wenn Ihre Organisation anhand der Aufgaben bei der Entwicklung von Software strukturiert ist, wie Analyse, Architektur, Entwicklung und Test. In so einem Fall könnten isolierte Kennzahlen sogar die Zusammenarbeit zwischen den Teams behindern. Wenn jedes Team an der Erfüllung der eigenen Kennzahl gemessen wird, dann wird es auch alles danach ausrichten, diese zu optimieren, und zur Not die Schuld, wenn es nicht klappen sollte, bei anderen suchen.

Zusammenfassen

Um nicht reduzierend zu wirken kann man Kennzahlen auch kombinieren. Dafür müssen sie natürlich zuerst in ein einheitliches Format gebracht werden. Für Software bietet es sich an, Verfehlungen bei Metriken in Aufwänden zu messen, welche im Zuge einer Behebung anfallen würden. Wenn es sich bei der Metrik beispielsweise um “Anzahl zyklischer Abhängigkeiten zwischen Modulen” handelt, dann kann diese Umrechnung erfolgen, indem man eine Zeiteinheit (z.B.: 1 Manntag) definiert, welcher nötig wäre, um einen Zyklus im Code zu beheben. Die Aufwände berechnen sich dann wie folgt:


(Anzahl_Zyklen – Obergrenze_Anzahl_Zyklen) * Aufwand_pro_Zyklenbehebung


Wenn Sie das für all Ihre Kennzahlen machen, können Sie die Aufwände am Ende summieren. Das u.a. als Plugin für SonarQube erhältliche SQALE Rating tut etwas ähnliches. Es errechnet zuerst die Kosten der gefundenen Issues im Code (Technical Debt) und erstellt daraus ein Scoring indem es die Kosten für Issues zur Quantität des Codes in Relation setzt. Das Ergebnis geht dann von A (gut) bis F (schlecht) und ist somit sehr plakativ. Etwas problematisch an SQALE finde ich, dass es teilweise Kennzahlen verwendet, welche in meinen Augen “Kobras” sind, wie die Anzahl der dokumentierten public Methoden in Java. Diese sollte man nicht messen, da es dadurch dazu kommen kann, dass veraltete und unverstandene Kommentare von den Entwicklern nicht gelöscht werden. In so einem Fall ist aber kein Kommentar besser als ein schlechter Kommentar. Außerdem ist es möglich (und auch besser) Code auf eine Art und Weise zu schreiben, sodass er im Endeffekt selbsterklärend ist, wodurch es dann keinen expliziten Kommentar mehr braucht.

Gezielte Auswahl für einen bestimmten Anwendungsfall

Es gibt meiner Erfahrung nach durchaus Problemgebiete, deren Erfüllungsgrad durch einige sehr passende Kennzahlen sehr gut wiedergegeben werden. Die Qualität der Strukturen von Software ist so ein Beispiel. Wenn Sie dies messen möchten, so empfehle ich Ihnen die Kennzahl NCCD aus der Familien der Kennzahlen von John Lakos. Eine Alternative stellt die Messung und Kontrolle der Relativen Strukturzyklizität dar, welche auch gut Schritt-für-Schritt gezielt erreicht werden kann, was motivierende Effekte auf ein Team haben kann.

Lockerer Umgang mit dem Thema

Monetäre Anreize führen manchmal zu einer Übermotivation bei der Erfüllung einer bestimmten Metrik. Und das Team vernachlässigt dann andere Aspekte des Erfolgs. Ähnlich verhält es sich, wenn aufgrund einer Untererfüllung eines Kennzahl-Grenzwertes harte Entscheidungen getroffen werden. Wenn in so einem Fall nicht mehr deployt werden kann, dann werden sich die Mitarbeiter Tricks einfallen lassen, um diese Kennzahl zur Not irgendwie noch zu erfüllen. Stattdessen können Sie auf die intrinsische Motivation Ihrer Mitarbeiter setzen. Kommunizieren Sie Ihrem Team bei jeder Gelegenheit wie weit es bei der Erfüllung seiner Ziele bereits ist. Wenn die Mitarbeiter bei der Auswahl der Kennzahlen teilhaben durften, wird die Motivation umso höher sein.

Fitness Functions

Fitness Functions, als Idee aus dem Buch Building Evolutionary Architectures von Neal Ford, Rebecca Parsons und Patrick Kua, basieren nicht selten auf Metriken, gehen aber in ihrer Definition noch darüber hinaus. Es werden dabei entweder punktuell oder laufend, einzelne oder gesamtheitliche Aspekte der Software überwacht. So kann ein einfacher Unit-Test, der auf ArchUnit oder JDepend basiert prüfen, ob die Modulstruktur des Systems auch frei von zyklischen Abhängigkeiten ist. Dies wäre atomar und punktuell. Die Simian Army von Netflix wiederum prüft kontinuierlich und holistisch die Stabilität der Produktionsumgebung. Mehr Informationen dazu im Blog-Beitrag zum Thema Evolutionäre Architektur.

Fazit

Metriken können ein mächtiges Werkzeug zur Entwicklung und Kontrolle diverser Qualitätsaspekte im Unternehmen sein. Bei der Auswahl und dem Einsatz ist aber Vorsicht geboten. Im Zuge meines Trainings zum Thema Software-Design erlernen die Teilnehmer Schritt für Schritt worauf es bei Messung und Entwicklung effektiver Strukturqualität ankommt.

Nähere Informationen zu diesem Thema finden Sie in meinem Buch Grundlagen des modularen Softwareentwurfs, dessen Kapitel 9 zu diesem Zweck mit freundlicher Genehmigung des Carl Hanser Verlages zur Verfügung gestellt wurde:

Download: Grundlagen des modularen Softwareentwurfs / Kapitel 9

Modularer Software Entwurf_HDowalil

Buch: Grundlagen des modularen Softwareentwurfs

By | Bücher, Publikationen | No Comments
Grundlagen des modularen Softwareentwurfs

Der Bau langlebiger Mikro- und Makro-Architekturen wie Microservices und SOA 2.0

Cover Grundlagen des modularen Softwareentwurfs, 2018
Autor: Herbert Dowalil
Deutsch, 224 Seiten, Mai 2018
Verlag: Hanser Fachbuch
ISBN: 978-3-446-45509-2
Das Buch bei Amazon kaufen
Beiträge des Autors im Hanser Update Blog
Die digitale Transformation der Gesellschaft bringt für bestehende IT-Landschaften neue Herausforderungen mit sich. Enterprise-Architekturen, welche sich oft durch ungeplant entstandene Komplexität auszeichnen, sollen plötzlich weiter wachsen. Klassische Muster für Enterprise-Architekturen geraten dabei an ihre Grenzen. Moderne Prinzipien und Muster werden entwickelt, um eben diese Komplexität in geordnete Bahnen zu lenken. Der Fokus dieses Buches liegt darauf, softwareintensive Systeme zu strukturieren und so den Bau effizienter und langfristig wartbarer Softwarearchitektur zu ermöglichen.


Erfahren Sie Grundlegendes zu verschiedenen Definitionen des Themas Softwarearchitektur, und wie diese in Wechselwirkung zur Organisation eines Unternehmens stehen. Lernen Sie die Prinzipien des modularen Softwaredesigns kennen. Durch den Einsatz entsprechender Pattern entsteht eine gut wartbare Codebasis, die dazu in der Lage ist, langfristig weiter zu wachsen. Muster langlebiger Enterprise SOA – die Königsdisziplin der Softwarearchitektur ist der Entwurf großer IT-Landschaften. Lesen Sie, wie sich die Muster gut strukturierten Codes auch auf die Strukturen einer Makro-Architektur anwenden lassen.

Monoliths_Microservices_Modularity

Monoliths, Microservices and Modularity – DZone Article

By | Artikel, Inhaltliches | No Comments
Monoliths, Microservices and Modularity

DZone

In this article, I want to have a look at this expected advantages, and if the microservice architectural style does live up to its expectations. Especially when compared to monolithic architectures. To do so, we are still lacking the definition of the term „Monolith.“ Some use that term for software, that grew to a total mess, completely lacking any structure. For this, I will rather use the term „Big Ball of Mud“ (BBoM). A monolith according to my definition is rather a software, built with one technology and based on modules that interact using the mechanisms of the particular technology they are built with. So the difference between microservices and monoliths is, that in a microservice architecture the modules are distributed, whereas in a monolith they are not. A BBoM can be distributed too, so this is certainly not a unique selling point of monolithic architectures.

read more

 
follow us on Twitter – @embarced

Artikel im Objektspektrum 03/2018: Digitalisierung, SOA und die Softwarekrise

By | Artikel, Publikationen | No Comments
Digitalisierung, SOA und die Softwarekrise

OBJEKTspektrum 03/2018

“ Digitalisierung, SOA und die Softwarekrise“
Autor: Herbert Dowalil
Artikel im OBJEKTspektrum 03/2018
erschienen am 27. April 2018

Die Digitale Transformation stellt über die Jahre gewachsene IT-Landschaften vor neue Herausforderungen. Zeit um einen kritischen Blick auf das Architekturmuster der SOA zu werfen, welches nach wie vor einen hohen Verbreitungsgrad besitzt, und zu klären, ob und wie es hilft, die Kontrolle über diese komplexen Legacy-Systemlandschaften wiederzuerlangen.

Digitale Ausgabe Objektspektrum

 
follow us on Twitter – @embarced