Child pages
  • FAE WS 20/21 - Knowledge Map

FAE WS 20/21 - Knowledge Map

Diese Seite versucht sich an einer "Knowledge Map" für diese Veranstaltung. Sie enthält zwei Informationen: 

  1. Die Selbsteinschätzung der Teilnehmenden, welchen Grad an Vertrautheit sie mit Teilaspekten der Architektur haben. Das abgefragte Raster listete sowohl zentrale Prinzipien und Konzepte wie auch wichtige Technologien und Tools in diesem Bereich. 
  2. Materialien zum Selbstlernen sowie Literaturhinweise, um sich die entsprechenden inhaltlichen Bereiche zu erschließen. 

Legende für Umfrage

Die Ergebnisse der Umfrage sind nach folgenden Farbschlüssel dargestellt:

Agiles Projektvorgehen

(nicht in der Umfrage abgefragt)

Prinzipien der agilen Entwicklung

Tools zur Taskplanung

  • Zenhub + Github Issues
  • JIRA
  • Trello


SW-Development

Java und Git sind gut vertraut, Spring nicht durchgehend. 

Entwicklung mit Spring (Spring Data JPA, Web MVC, Data REST)


Domain-Driven Design (DDD)

Durchgehend ähnliches Bild: Konzepte sind bekannt, aber nicht durchgehend vertraut und schon aktiv benutzt

Allgemeine Grundlagen Domain-Driven Design

Entitites und Value Objects

Bounded Contexts & Context Maps

Domain- und Application Services


Architekturstile großer Softwaresysteme

  • Wenig Vertrautheit mit Microservice und Modulith
    • klassischer Monolith eher vertraut, aber Begriff nicht durchgängig gebräuchlich?

Schichtenarchitektur nach DDD

Microservices / "Modulith" (Monolith mit striktem fachlichen Schnitt)


APIs (REST oder Alternativen)

  • Etwa die Hälfte der Teilnehmenden hat aktiv Berührung gehabt, aber tiefe Vertrautheit ist selten. 
  • GraphQL ist fast durchgehend unbekannt

Aggregates als DDD-Grundlagen für REST

Prinzipien eines "guten" REST-API-Designs

Implementieren von REST mit Spring (Web MVC oder Data REST)

GraphQL (als mögliche Alternative zu REST)

Prinzipien der API-Entwicklung (API first / Code first)

Formate / Tools für Dokumentation von REST APIs


Asynchrone Kommunikation (Events)

  • Durchgehend wenig Vertrautheit mit Konzepten und Technologien
  • tbd:
    • gezielte Recherche in den SIGs
    • Information der restlichen Teilnehmenden auf diesem Weg

Methoden der Erhebung fachlicher Events (z.B. Event Storming)

Prinzipien des Eventings (Event-Carried State Transfer, Event Sourcing, Event Notification)

Apache Kafka

Spring Boot Application Events

Formate / Tools für Dokumentation von Events


DevOps

  • uneinheitliches Build: einige Teilnehmenden sind vertraut mit vielen der Themen, viele nicht
    • Build Tools scheinen (relativ) gut vertraut
    • Docker, staging, hosting - gemischtes Bild
    • Kubernetes: generell wenig Vertrautheit
  • tbd:
    • "learning by doing"
      • bei einigen Themen ist das leichter als bei anderen
    • "Basis-Set" an Wissen
    • arbeitsteiliges Vorgehen
    • Developer Guide für DevOps-Themen

Build Tools (Maven, Gradle, ...)

Build Pipeline (Jenkins, ...)

Docker

Kubernetes

Staging-Konzepte (Dev- / Prod-Umgebungen)

Hosting von SW-Applikationen (VMs, Cloud, ...


Testing

  • Unit Tests gute Vertrautheit, Integration Tests schon weniger
  • Events und Test Data Management weitgehend blank
  • tbd:
    • Videos zum Selbststudium
    • ?

Unit Tests mit JUnit

Integration Testing von APIs

Integration Testing von Events

Test Data Management


Literatur

Hier ist eine umfangreiche Liste von Literatur zur Veranstaltung. Fettgedruckte Autorennamen bedeuten, dass die Publikation in der Veranstaltung eine besondere Rolle spielen wird. 

  1. Balzert, H. (2011). Lehrbuch der Softwaretechnik: Entwurf, Implementierung, Installation und Betrieb (3. Aufl. 2012). Spektrum Akademischer Verlag.
  2. Bente, S., Deterling, J., Reitano, M., & Schmidt, M. (2020, March 27). Sieben Weggabelungen—Wegweiser im DDD-Dschungel. JavaSPEKTRUM, 2020(02), 28–31.
  3. Bloomberg, J. (2013). The Agile Architecture Revolution: How Cloud Computing, REST-Based SOA, and Mobile Computing Are Changing Enterprise IT (1. Auflage). John Wiley & Sons.
  4. Dowalil, H. (2019). Modulith First! Der angemessene Weg zu Microservices. Informatik Aktuell. https://www.informatik-aktuell.de/entwicklung/methoden/modulith-first-der-angemessene-weg-zu-microservices.html
  5. Esposito, D., & Saltarello, A. (2014). Discovering the Domain Architecture. In Microsoft .NET - Architecting Applications for the Enterprise (2nd edition). Microsoft Press. https://www.microsoftpressstore.com/articles/article.aspx?p=2248811&seqNum=3
  6. Evans, E. (2015). Domain-Driven Design Reference—Definitions and Pattern Summaries. Domain Language, Inc. http://domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf
  7. Evans, E. (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software (1 edition). Addison-Wesley Professional.
  8. Fielding, Roy T., & Taylor, R. N. (2002). Principled design of the modern Web architecture. ACM Transactions on Internet Technology (TOIT), 2(2), 115–150.
  9. Fielding, Roy Thomas. (2000). Architectural styles and the design of network-based software architectures. University of California, Irvine.
  10. Fowler, M. (2002). Patterns of Enterprise Application Architecture (1 edition). Addison-Wesley Professional.
  11. Fowler, M. (o.J.). Data Transfer Object. https://martinfowler.com/eaaCatalog/dataTransferObject.html
  12. Fowler, M. (2010, March 18). Richardson Maturity Model. Martinfowler.Com. https://martinfowler.com/articles/richardsonMaturityModel.html
  13. Fowler, M. (2014, January 15). Bounded Context. Martinfowler.Com. https://martinfowler.com/bliki/BoundedContext.html
  14. Fowler, M. (2017, February 7). What do you mean by “Event-Driven”? Martinfowler.Com. https://martinfowler.com/articles/201701-event-driven.html
  15. Fowler, M. (2018). Refactoring: Improving the Design of Existing Code (2nd ed.). Addison-Wesley Professional.
  16. Gauder, S. (2019, April 1). A competitive food retail architecture with microservice. microxchg 2019. https://speakerdeck.com/rattakresch/microxchg-2019-a-competitive-food-retail-architecture-with-microservice
  17. Goll, J. (2014). Architektur- und Entwurfsmuster der Softwaretechnik. Springer Fachmedien Wiesbaden. http://link.springer.com/10.1007/978-3-658-05532-5
  18. Graca, H. (2017, November 16). DDD, Hexagonal, Onion, Clean, CQRS, … How I put it all together. @hgraca. https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/
  19. Holmström, P. (2020). Domain-Driven Design and the Hexagonal Architecture. Vaadin. https://vaadin.com/learn/tutorials/ddd/ddd_and_hexagonal
  20. Jackson, C. (2019, June 19). Micro Frontends. Martinfowler.Com. https://martinfowler.com/articles/micro-frontends.html
  21. Levin, G. (2017, March 25). Internal vs. External APIs. REST API and Beyond. http://blog.restcase.com/internal-vs-external-apis/
  22. Lilienthal, C. (2015). Langlebige Software-Architekturen: Technische Schulden analysieren, begrenzen und abbauen (1st ed.). dpunkt.verlag GmbH.
  23. Lilienthal, C. (2019, March 25). Von Monolithen über modulare Architekturen zu Microservices mit DDD. JAX 2020. https://jax.de/blog/microservices/von-monolithen-ueber-modulare-architekturen-zu-microservices-mit-ddd/
  24. Martin, R. C. (2017). Clean Architecture: A Craftsman’s Guide to Software Structure and Design (01 ed.). Prentice Hall.
  25. Massé, M. (2011). REST API Design Rulebook (1st ed.). O’Reilly and Associates.
  26. Müller, F. (2017, November 10). How to be an Architect in an Agile World. 17. Arbeitstreffen User Group Architekturmanagement, Softwareforen Leipzig. https://www.softwareforen.de/portal/Veranstaltungen/User-Groups/Architekturmanagement/Startseite.xhtml
  27. Newman, S. (2015). Building Microservices (1st ed.). O’Reilly and Associates.
  28. Richardson, C. (2015, May 19). Introduction to Microservices. NGINX. https://www.nginx.com/blog/introduction-to-microservices/
  29. Richardson, C. (2018). Microservice Patterns. Manning.
  30. Samokhin, V. (2018, January 18). DDD Strategic Patterns: How to Define Bounded Contexts - DZone Microservices. Dzone.Com. https://dzone.com/articles/ddd-strategic-patterns-how-to-define-bounded-conte
  31. Starke, G. (2015). Effektive Softwarearchitekturen: Ein praktischer Leitfaden (7th ed.). Carl Hanser Verlag GmbH & Co. KG.
  32. Steinacker, G. (2016, March 20). Why Microservices? Dev.Otto.De. https://dev.otto.de/2016/03/20/why-microservices/
  33. Sturgeon, P. (2017, January 24). GraphQL vs REST: Overview. Phil Sturgeon. https://philsturgeon.uk/api/2017/01/24/graphql-vs-rest-overview/
  34. Tilkov, S., Eigenbrodt, M., Schreier, S., & Wolf, O. (2015). REST und HTTP: Entwicklung und Integration nach dem Architekturstil des Web (3., akt. u. erw. Aufl.). dpunkt.verlag GmbH.
  35. Toth, S. (2015). Vorgehensmuster für Softwarearchitektur: Kombinierbare Praktiken in Zeiten von Agile und Lean (2., aktualisierte und erweiterte Auflage). Carl Hanser Verlag GmbH & Co. KG.
  36. Vernon, V. (2013). Implementing Domain-Driven Design (01 ed.). Addison Wesley.
  37. Wolff, E. (2015). Microservices: Grundlagen flexibler Softwarearchitekturen (1., Auflage). dpunkt.verlag.
  38. Wolff, E. (2016b, November 29). Self-contained Systems: A Different Approach to Microservices. InnoQ Blog. https://www.innoq.com/en/articles/2016/11/self-contained-systems-different-microservices/
  39. Zörner, S. (2015). Softwarearchitekturen dokumentieren und kommunizieren: Entwürfe, Entscheidungen und Lösungen nachvollziehbar und wirkungsvoll festhalten (2., überarbeitete und erweiterte Auflage). Carl Hanser Verlag GmbH & Co. KG.