Stephan Görgens über Objektrelationale Mapper – Anwendungsentwickler-Podcast #108

Ein sehr interessantes Interview zum Thema Objektrelationale Mapper mit Stephan Görgens gibt es in der einhundertachten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Am Beispiel von Microsofts Entity Framework zeige ich dir, wie objektrelationale Mapper Klassen und Objekte mit Tabellen und Datensätzen verbinden. Mit Code-first entsteht das Datenbankschema aus deinen Klassen, während der DbContext den Zugriff auf die Datenbank und das Speichern übernimmt. SQL gehört weiterhin zu deinem Handwerkszeug, weil große Datenmengen und zeitkritische Aufgaben gezielte Eingriffe erfordern. Für deine Projekte empfehle ich etablierte Frameworks und eigene Tests mit einer Datenbank; zusätzliche Schichten hängen davon ab, wie umfangreich dein Projekt wird.

Kapitelmarken

  • [00:00:00] Einstieg ins Thema objektrelationale Mapper
  • [00:01:39] Stefan Görgens und das Berichtswesen bei BMW
  • [00:03:31] Von der Elektrotechnik zur Informatik
  • [00:07:48] Clean Code und die Arbeit mit C# und .NET
  • [00:12:37] Was ein ORM macht
  • [00:14:13] Klassen und Objekte auf Tabellen und Datensätze abbilden
  • [00:17:06] Entity Framework, NHibernate und JPA
  • [00:19:11] Kosten, Installation und die Wahl eines Frameworks
  • [00:22:06] Grafische Designer und Code-first
  • [00:23:53] Das Datenmodell aus Klassen erstellen
  • [00:25:56] Schrittweise entwickeln und Migrationen verwalten
  • [00:27:42] Connection-String und DbContext
  • [00:29:39] Konventionen und Annotationen
  • [00:34:49] Beziehungen und Kardinalitäten abbilden
  • [00:37:50] Änderungen speichern und den Kontext freigeben
  • [00:38:54] Große Datenmengen und direkte SQL-Befehle
  • [00:39:53] LINQ to Entities und weitere Abfragemöglichkeiten
  • [00:43:49] SQL verstehen und bei Performance-Problemen eingreifen
  • [00:46:24] SQL-Ausgaben und Logging
  • [00:50:07] Aufwand und Grenzen eines ORMs
  • [00:52:07] Architektur und Schichten im Projekt
  • [00:55:53] ORM und Datenbank austauschen
  • [01:03:16] Den DbContext erzeugen und seine Lebensdauer steuern
  • [01:06:35] Tests mit einer In-Memory-Datenbank
  • [01:09:11] Integrationstests und Fehler eingrenzen
  • [01:13:01] Etablierte Frameworks für eigene Projekte
  • [01:13:56] Domänenmodell und Data-Access-Layer
  • [01:17:19] Quellen zu Entity Framework und Literaturtipps
  • [01:21:05] Clean Code und weitere prägende Bücher
  • [01:22:38] Weiterlernen während der Arbeitszeit
  • [01:26:29] Studierende betreuen und Wissen weitergeben
  • [01:28:52] Kontakt, Praktikum und Abschlussarbeit bei BMW
  • [01:31:08] Verabschiedung
  • [01:31:47] Shownotes zur Episode

Probeabo bei Audible (Affiliate)

Inhalt

Die folgenden Fragen zum Bereich der objektrelationalen Mapper gehen wir im Verlauf des Interviews durch.

Objektrelationale Mapper

  • Was ist ein ORM?
  • Warum braucht man einen ORM bzw. sollte ihn verwenden?
  • Was sind Beispiele für bekannte ORMs?
  • Mit welchen ORMs hast du selbst schon gearbeitet?
  • Was ist dein Lieblings-ORM und warum?
  • Was sollte ein ORM mindestens können?
  • Wie konfiguriert man einen ORM?
  • Wie setzt man komplexe Datenbankabfragen mit einem ORM um?
  • Wie integriert man einen ORM am besten in eine Anwendungsarchitektur?
  • Ab wann „lohnt“ sich der Einsatz eines ORMs im Projekt?
  • Wie stark macht man sich beim Einsatz eines ORMs von diesem abhängig?
  • Sollte man einen ORM einfach austauschen können?
  • Wie wichtig ist das Beherrschen von SQL, wenn man mit ORMs arbeitet?
  • Sollten auch Azubis schon mit ORMs arbeiten und warum (nicht)?
  • Welche Nachteile haben ORMs?
  • Welche Literaturempfehlungen hast du für den Bereich ORMs?

Literaturempfehlungen

Stephan empfiehlt für Einsteiger ins Thema Moderne Datenzugriffslösungen mit Entity Framework 6: Datenbankprogrammierung mit .NET und C#* von Dr. Holger Schwichtenberg.

*

Und hier gibt es den „.NET-Doktor“ live zu sehen.

Außerdem ist Stephan – genau wie ich – der Meinung, dass Clean Code* auf keinem Entwicklernachttisch fehlen sollte 😉

Robert C. Martin - Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)*

Links

Zusammenfassung

Aus der Praxis bei BMW

Für den Einstieg in objektrelationale Mapper greife ich auf das Gespräch mit Stefan Görgens zurück, der bei BMW im Berichtswesen für die Qualität während der Produktion arbeitet. Seine Abteilung entwickelt Software, mit der Qualitätsdaten erfasst und für Berichte aus Datenbanken gelesen werden. Ein ORM gehört dort zum Standard neuer Softwareprojekte.

Görgens kam über eine elektrotechnische Ausbildung und ein Elektrotechnikstudium zur Softwareentwicklung. Nach einem Softwareprojekt für seine Abschlussarbeit bei BMW studierte er angewandte Informatik bis zum Master. Durch das Buch Clean Code beschäftigte er sich stärker damit, wie sich Software testen und später weiterentwickeln lässt. Im beruflichen Alltag arbeitet er vor allem mit C#, weil sein Unternehmen auf .NET setzt.

Wie ein ORM deine Objekte mit der Datenbank verbindet

Wenn du als Fachinformatiker:in Anwendungsentwicklung mit einer relationalen Datenbank arbeitest, müssen deine Objekte dauerhaft gespeichert werden. Ein objektrelationaler Mapper, kurz ORM, übernimmt dabei das Zuordnen zwischen der objektorientierten Programmiersprache und der relationalen Datenbank.

Für den einfachen Fall gelten folgende Beziehungen:

  • Eine Klasse entspricht einer Tabelle.
  • Ein Objekt entspricht einem Datensatz.
  • Die Eigenschaften der Klasse entsprechen den Spalten.
  • Beziehungen zwischen Objekten werden als Beziehungen in der Datenbank abgebildet.

Dadurch kannst du mit den Daten als Objekte arbeiten und sie beispielsweise in Listen verwalten. Das Framework übernimmt Aufgaben, die du sonst selbst programmieren müsstest, etwa Daten aus der Datenbank in passende Objekte zu übertragen und Änderungen zurückzuschreiben. Das spart Arbeit und verringert Fehler beim Datenzugriff. Ein einmal erarbeiteter Ansatz lässt sich in weiteren Projekten wieder einsetzen.

Entity Framework und andere ORMs

Im .NET-Umfeld arbeitet Görgens mit Microsofts Entity Framework. Für seine Abteilung sprechen die laufende Entwicklung und die verfügbaren Informationen dafür. Auch interne Freigaben sind bei einem Produkt von Microsoft unter den dortigen Bedingungen leichter zu bekommen.

Als Alternative nennt er NHibernate, das aus der Java-Welt stammt. Kenntnisse daraus lassen sich auf Hibernate in Java übertragen. Im Java-Umfeld gibt es außerdem JPA, die Java Persistence API: Sie legt eine Schnittstelle fest, hinter der unterschiedliche ORM-Provider wie Hibernate oder EclipseLink arbeiten können.

Entity Framework ist kostenfrei und wird als eigenes Paket installiert, beispielsweise über NuGet in Visual Studio. Im Gespräch wird auch die damals noch junge Core-Variante angesprochen, mit der plattformübergreifendes Entwickeln möglich wird. Die grundlegenden ORM-Konzepte gelten über .NET hinaus.

Mit Code-first das Datenmodell entwickeln

Bei Code-first schreibst du deine Klassen und legst einen Datenbankkontext an. Aus diesem Code erstellt Entity Framework die Tabellen. Vorher solltest du dir Gedanken über dein Datenmodell machen und es grob aufzeichnen.

Für neue Projekte empfiehlt Görgens diesen Weg, weil sich die Klassen im Code gut überblicken lassen. Verständliche Namen und passende Ordner helfen dir, später wieder ins Projekt einzusteigen. Die Dateien bleiben als Text zugänglich.

Ein grafischer Designer liefert beim Lernen schnell ein Ergebnis. Görgens sieht dabei das Problem, dass viele Schritte im Hintergrund ablaufen und Details erst in den jeweiligen Eigenschaften sichtbar werden.

Mit Code-first kannst du dein Modell während der Arbeit weiterentwickeln. Migrationen übertragen Änderungen auf die Datenbank. Entity Framework hält dabei fest, welche Versionen angewendet wurden; Änderungen lassen sich auch wieder zurücknehmen. Das passt zu einem schrittweisen oder testgetriebenen Vorgehen.

Konventionen und Beziehungen

Entity Framework erkennt vieles anhand seiner Konventionen. Eine passend benannte ID-Eigenschaft wird beispielsweise als Schlüssel erkannt. Über Annotationen oder Einstellungen im DbContext kannst du die Zuordnung verändern, etwa wenn Tabellen anders heißen sollen. Auch das automatische Bilden englischer Pluralformen für Tabellennamen lässt sich beeinflussen.

Ich empfehle dir, dich zunächst an die vorgesehenen Konventionen zu halten. Dadurch bleibt leichter nachvollziehbar, wie eine Klasse mit ihrer Tabelle zusammenhängt, und du sparst dir zusätzliche Einstellungen.

Beziehungen kannst du über Eigenschaften und Sammlungen ausdrücken. Eine Liste von Kursen in einer Klasse für eine:n Student:in stellt beispielsweise einen Bezug zu diesen Kursen her. Bei n:m-Beziehungen kommt eine Zwischentabelle ins Spiel. Hat die Beziehung eigene Eigenschaften, etwa eine Uhrzeit, wird im Gespräch eine eigene Klasse dafür vorgeschlagen.

Wie viel du zusätzlich festlegen musst, hängt vom Datenmodell ab. Ein über viele Jahre gewachsenes Schema kann mehr Anpassungen erfordern.

Mit dem DbContext arbeiten und Änderungen speichern

Der DbContext ist die zentrale Schnittstelle beim Arbeiten mit Entity Framework. Er verwaltet die Entities und kümmert sich um die Verbindung zur Datenbank. Dafür braucht er einen Connection-String, der im beschriebenen Beispiel in der Anwendungskonfiguration steht.

Du kannst einen Kontext mit new erzeugen und innerhalb eines using-Blocks damit arbeiten. Weil er IDisposable implementiert, werden seine Ressourcen beim Verlassen des Blocks freigegeben. Mehrere Kontexte können unabhängig voneinander existieren.

Änderungen werden zunächst lokal verwaltet. Zum dauerhaften Speichern musst du ausdrücklich den entsprechenden Aufruf auslösen, damit die geänderten Daten in die Datenbank geschrieben werden.

SQL, LINQ und große Datenmengen

SQL-Kenntnisse brauchst du auch beim Arbeiten mit einem ORM. Das Framework erzeugt SQL und bringt zusätzliche Verarbeitung mit sich. Sobald du verstehen möchtest, warum ein Zugriff lange dauert, hilft dir das Wissen über die Abläufe in der Datenbank.

Ein Beispiel ist das Ändern eines Flags in sehr vielen Datensätzen. Wenn dafür hunderttausende Objekte zunächst in den Arbeitsspeicher geladen werden, entsteht Aufwand. Ein gezieltes SQL-Statement kann die betreffende Spalte direkt in der Datenbank ändern.

Für viele Abfragen bietet LINQ to Entities einen typisierten Weg innerhalb von C#. Dabei unterstützen dich der Compiler und die Entwicklungsumgebung. Im Gespräch werden außerdem Entity SQL und direktes SQL als weitere Möglichkeiten genannt.

Welche Variante passt, richtet sich nach der Aufgabe und den zeitlichen Anforderungen. SQL gehört auch zu den Inhalten der Abschlussprüfung für IT-Azubis und hilft dir, bei Problemen unterhalb des Frameworks weiterzuarbeiten.

Ausgeführtes SQL nachvollziehen

Entity Framework kann die erzeugten SQL-Statements ausgeben. Im Gespräch werden Ausgaben über die Konsole sowie das Schreiben von Informationen in Datenbanktabellen beschrieben.

Damit kannst du verfolgen, was zu einem bestimmten Zeitpunkt ausgeführt wurde. Solche Informationen helfen dir beim Suchen nach Fehlern und unterstützen eine:n Datenbankadministrator:in dabei, hohe Last nachzuvollziehen. Wenn weitere Logs in der Datenbank liegen, lassen sich diese Informationen zusammenführen.

Architektur und zusätzliche Schichten

Bei kleinen Projekten reicht zunächst eine einfache Struktur. Mit zunehmendem Umfang solltest du zusammengehörige Klassen ordnen und festlegen, an welchen Stellen der DbContext verfügbar sein soll.

Ein Data-Access-Layer oder ein Data-Manager kann den Zugriff auf die Datenbank kapseln. Dadurch lassen sich Abhängigkeiten aus der Geschäftslogik herausziehen. Ob sich diese zusätzliche Schicht lohnt, hängt von deinem Projekt ab.

Ein ORM wird in der Praxis selten ausgetauscht. Auch der Wechsel der Datenbank verursacht Aufwand und kann bei produktiven Anwendungen riskant sein. Im Gespräch werden Datenbank-Links als Möglichkeit genannt, Daten aus einem anderen System einzubinden.

Für ein unabhängigeres Domänenmodell spielt ebenfalls eine Rolle, wo der Zugriff auf das Framework stattfindet. Ein direkt verwendeter DbContext koppelt den betreffenden Code daran. Zusätzliche Schichten werden besonders dann interessant, wenn Änderungen in größeren Projekten aufwendig werden.

Den Datenzugriff testen

Für meine Projekte mit IT-Azubis empfehle ich eigene Tests, die nachweisen, dass Daten gespeichert und wieder gelesen werden können. Dafür wird im Gespräch eine In-Memory-Datenbank beschrieben. Die passenden Testdaten musst du selbst anlegen und an dein Projekt anpassen.

Görgens übernimmt die Grundstruktur solcher Tests in weitere Projekte. So lässt sich beispielsweise prüfen, ob eine geänderte Feldlänge oder ein anderer Datentyp wie vorgesehen verarbeitet wird.

Im Java-Umfeld kann ein Entity Manager zusätzlich durch einen Fake oder Stub ersetzt werden. Tests mit einer Datenbank prüfen das Zusammenspiel mit dem ORM. Solche Integrationstests helfen dir auch dabei, Probleme im eigenen Code einzugrenzen, bevor du nach Ursachen im Netzwerk suchst.

Für produktive Projekte empfehle ich dir ein etabliertes ORM. Darin steckt bereits viel Arbeit erfahrener Entwickler:innen. Die Zeit, die du dadurch sparst, kannst du in Tests für dein Projekt investieren.

Quellen zum Weiterlernen

Als Einstieg und zum Vertiefen nennt Görgens folgende Quellen:

  • Microsofts Dokumentation zu .NET und Entity Framework.
  • Beiträge und Vorträge von Dr. Holger Schwichtenberg, dem .NET-Doktor.
  • Das Beispielprojekt WWWings, das in Schwichtenbergs Büchern und Vorträgen wieder auftaucht.
  • Das Buch "Moderne Datenzugriffslösungen mit Entity Framework 6".
  • Vorträge der BASTA!, teilweise auf YouTube verfügbar.
  • Videokurse, beispielsweise bei Pluralsight oder Udemy.

Zu den Büchern, die seinen Weg geprägt haben, zählt Görgens außerdem Clean Code sowie Objective-C and Cocoa.

Zum Beruf als Softwareentwickler:in gehört, sich regelmäßig mit neuen Entwicklungen zu beschäftigen und Dinge auszuprobieren. Dafür sollte auch während der Arbeitszeit Platz sein. Im Gespräch werden Extreme Programming und Code-Katas als Ansätze angesprochen, die Lernen im Arbeitsalltag unterstützen.

Praktikum und Abschlussarbeit

Görgens betreut bei BMW Studierende, die ein Praktikum machen oder ihre Abschlussarbeit schreiben. Wegen der langen Zeit zum Einarbeiten ist die Verbindung beider Phasen für seine Abteilung interessant. Dabei erhalten Studierende Freiraum, sich mehrere Wochen mit einem Thema zu beschäftigen, bevor sie es umsetzen.

Für Interessierte werden das Bewerbungsportal und der direkte Kontakt per E-Mail angesprochen. Die Kontaktmöglichkeiten und ergänzende Quellen sind für die Shownotes unter anwendungsentwicklerpodcast.de/108 vorgesehen.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:00] Herzlich willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker

[0:09] für Anwendungsentwicklung. In dieser Episode gibt es ein Interview mit Stefan Görgens

[0:13] zum Thema Objektrelationale Mapper. Viel Spaß!

[0:20] Hallo und herzlich willkommen zur 108. Episode des Anwendungsentwickler-Podcasts. Mein Name

[0:26] ist Stefan Macke und heute habe ich, wie in den letzten Wochen auch, ein super spannendes

[0:31] Interview für dich. Und zwar habe ich mich mit Stefan Görgens unterhalten über das

[0:35] Thema Objektrelationale Mapper. Wenn du in irgendeiner Weise schon im Enterprise-Umfeld

[0:40] aktiv bist oder auch schon in kleinen Programmierprojekten, ist der Einsatz von so einem ORM absolut sinnvoll

[0:46] und wir werden heute darüber sprechen, was so ein Ding eigentlich macht, wo da die Vor-

[0:51] und Nachteile vielleicht, wenn es sie denn gibt, auch sind und was man insgesamt vielleicht

[0:55] zum Thema wissen sollte. Ganz lange haben wir uns darüber unterhalten, aber es sind

[0:59] auch wirklich viele coole Inhalte drin und wir haben endlich mal die Möglichkeit gehabt,

[1:03] auch über die .NET-Plattform zu sprechen. Was Stefan mir auch nochmal am Ende sagt,

[1:08] findet er auch gut, dass wir das hier auch mal abdecken. Und nicht immer nur Java und

[1:11] all so ein anderes Zeug, denn es gibt ja auch noch die große .NET-Community da draußen,

[1:15] keine Frage. Und die soll heute mal insbesondere bedient werden, weil wir uns am ORM-Entity-Framework

[1:21] von Microsoft entlang hangeln. Aber auch wenn du nichts mit .NET machst, wirst du das trotzdem

[1:25] sicherlich gut gebrauchen können und auch nachvollziehen können, denn das Thema ORM

[1:29] ist ja ein allgemeines Thema in der Programmierung und nicht programmiersprach- oder plattformspezifisch.

[1:33] Aber bevor ich jetzt noch weiter ins Detail gehe, höre ich mal auf zu sabbeln und wir

[1:37] schalten rüber ins Interview. Viel Spaß!

[1:39] Ja, hallo Stefan! Damit wir einen schönen Einstieg finden, würde ich sagen, stell

[1:47] dich doch einfach mal kurz den Zuhörern selber vor. Wer bist du? Was machst du?

[1:51] Ja, schönen guten Tag! Mein Name ist Stefan, Stefan Görings und ich arbeite bei BMW im

[1:57] Qualitätsmanagement. Genauer gesagt im Berichtswesen. Ich bin im Berichtswesen für die

[2:02] Produktion zuständig und wir sind für die sämtlichen Qualitätszahlen während der

[2:06] Produktion im Werk verantwortlich. Das heißt, wir nehmen die Qualitätszahlen von der Datenbank,

[2:12] bauen Berichte und sorgen dafür, dass die Lenkung der Qualität funktioniert. Das ist so,

[2:18] ich sage mal, das Grobe.

[2:20] Okay, also Qualität im Sinne der Softwarequalität oder wirklich Qualität von so einem Auto?

[2:26] Nein, es geht um die Qualität des Autos. Ich habe jetzt mit der Qualität an sich,

[2:34] dass ich ein Spaltmaß kontrolliere, natürlich nichts zu tun, sondern ich sorge dafür,

[2:37] dass die Zahlen, die irgendwie in die Datenbank gelangen, dass die auch wieder rauskommen. Und

[2:41] wir sind halt für die Eingabe- und Ausgabesysteme verantwortlich und alles, was dazwischen steht.

[2:45] Und da wird inzwischen eine Menge Software gebraucht und halt auch Kleinigkeiten selber

[2:50] entwickelt, die halt einfach fehlen, weil auch SAP nicht alles liefern kann und erst recht nicht

[2:54] für den Preis, den man sich so vorstellt.

[2:56] Okay, das heißt, ihr arbeitet wahrscheinlich, was ja auch so ein bisschen unser Thema heute

[3:01] sein soll, mit objektrelationalen Mappern, um auf die Datenbank zuzugreifen und so weiter?

[3:06] Oder wie kann man sich das vorstellen?

[3:07] Richtig. Im Prinzip ist jedes Softwareprojekt, was wir anfangen, brauchen wir ein ORM,

[3:12] weil einfach ein Grundstandard sein muss, wie ich auf die Datenbank zugreife. Und bei uns besteht

[3:21] der ganze Tag aus Datenbanken, weil alle Daten, die unten aufgenommen werden in der Produktion,

[3:25] in der Datenbank landen und auf der anderen Seite wieder ausgegeben werden müssen. Und genau an

[3:30] der Schnittstelle arbeiten wir.

[3:31] Ah, okay. Und jetzt, bevor wir tiefer noch einsteigen in das Thema Datenbanken,

[3:36] wie bist du selber in den Bereich eingestiegen? Hast du irgendwie in dem Bereich was studiert

[3:41] oder eine Ausbildung gemacht? Oder wie kam es zu diesem Beruf, sage ich mal?

[3:45] Ja, auf Umwegen, sage ich mal. Ich habe eine Ausbildung als elektrotechnischer

[3:50] Assistent gemacht damals und habe dann nach der Ausbildung festgestellt, dass das jobtechnisch

[3:56] jetzt nicht so gut ist, weil es damals wenig Jobs gab in der Richtung und habe deswegen an

[4:00] der Fachhochschule in Düsseldorf Elektrotechnik studiert. So hat das Ganze angefangen. Ich habe

[4:05] damals meine Abschlussarbeit bei BMW geschrieben und dort habe ich ein Softwareprojekt gemacht,

[4:10] weil ich als Fachrichtung Informationstechnik hatte. Danach stand für mich fest, ich mache

[4:17] irgendwie weiter mit Software und daraufhin wollte ich meinen Master an einer Uni machen in Sachen

[4:23] Informatik. Das war nicht ganz so einfach, weil auch trotz passender Noten ich nicht genommen

[4:29] worden bin und man sich einfach mit dem FH-Titel schwergetan hat. Dann habe ich mit vielen,

[4:36] vielen Bewerbungen und vielen Diskussionen es dann nachher geschafft, im Prinzip das ganze

[4:41] Informatikstudium nochmal zu machen bis zum Master und habe dann meinen Master in angewandter

[4:46] Informatik gemacht. Das hört man oft, dass Leute, die auch im Bereich E-Technik vielleicht starten,

[4:53] dann letztlich doch irgendwie in der Softwareentwicklung landen, weil halt so auch diese

[4:56] ganze Embedded-Schiene und so weiter ja schon wirklich sehr, sehr softwarelastig auch ist.

[4:59] Ja, genau. Wenn man halt die Informationstechnik, was halt früher so mehr Antennentechnik und

[5:06] Übertragungstechnik war, geht halt heute immer weiter Richtung Software und so hat das ganze

[5:11] seinen Lauf genommen und das einzig Schwierige war halt der Umstieg von FH an die Uni und man

[5:16] hat mich halt nicht direkt in den Master gelassen, trotz Abschluss mit passender Note. Das hat nicht

[5:20] funktioniert. Das kann man natürlich sagen, da kann man sich im Zweifelsfall einklagen,

[5:24] aber naja, man trifft im Zweifelsfall nachher wieder auf die Professoren, die daran dann

[5:29] beteiligt sind, insofern tut man es besser und sagt dann schreibe ich eben nochmal sieben,

[5:33] acht Klausuren mehr und dann ist es gut.

[5:34] Ja, ich habe tatsächlich, als ich in Nürnberg Software Engineering studiert habe,

[5:42] das war auch extra ein Master, der sogar auch die Zielgruppe E-Techniker hatte und wir hatten,

[5:47] glaube ich, also gefühlt die Hälfte der Leute waren auch E-Techniker und die haben dann halt

[5:51] irgendwie schon seit Jahren mit C und C++ irgendwelche Sachen programmiert, aber eigentlich

[5:55] nie so richtig Softwareentwicklung gelernt und das war dann quasi die Zielgruppe dieses

[6:00] Studiengangs und die fanden das eigentlich alle sehr gut. Also die haben tatsächlich dann auch

[6:05] durchaus mit einem FH-Abschluss dann dort das Studium machen können, aber gut, das war auch

[6:10] selber damals noch eine Fachhochschule. Das war vielleicht von daher der Unterschied zur

[6:13] Universität, aber die haben das auf jeden Fall auch dann genutzt, um ihr Tagesgeschäft eigentlich

[6:19] auch nochmal auf professionelle Beine zu stellen, also wirklich auch die Hintergründe der Softwareentwicklung

[6:22] dann nochmal zu lernen.

[6:23] Ja, richtig, genau. Das ist so ein Punkt, der mir auch aufgefallen ist und den ich jetzt so,

[6:27] ja, als Elektrotechniker, der dann nachher Informatik gemacht hat, ganz gut sagen kann.

[6:33] In einem Unternehmen, wo ich als Student gearbeitet habe, war auch Softwareentwicklung und da war die

[6:39] halt durch Elektrotechniker. Damals war ich noch der Meinung, dass das alles ganz gut lief. Durch die

[6:44] Brille heute würde ich sagen, das lief nicht gut und genau aus dem Grund, weswegen du es gesagt hast.

[6:49] Also die Elektrotechnik hat zwar Programmierung, ja, die hat es aber durch eine sehr bestimmte

[6:56] Brille. Die gucken in eine Richtung und da ist eher das Ergebnis wichtig und nicht der Weg.

[7:03] Während bei der Informatik halt nachher es wichtig ist, dass auch die Software, die ich

[7:07] geschrieben habe, getestet ist, dass sie funktioniert und dass man sie auch weiterentwickeln kann.

[7:12] Und den Fokus hat man als Elektrotechniker meiner Meinung nach nicht.

[7:16] Okay, ja, das ist natürlich spannend, wenn man quasi die Software nur, sage ich mal, als Mittel

[7:24] zum Zweck sieht, um quasi sein kleines elektrotechnisch gebautes Ding eben jetzt

[7:28] laufen zu kriegen, dann hat man vielleicht selber auch ein bisschen andere Qualitätsansprüche da dran.

[7:32] Ja, es ist halt einfach viel viel Hardware näher, dass man sich einfach gar nicht mit vielen Dingen

[7:37] drumherum erstens beschäftigen muss und zweitens es auch nicht braucht vielfach. Und wie du es

[7:42] eben schon sagtest, C ist halt so ein großes Thema und man bleibt halt relativ Hardware nah.

[7:48] Machst du denn im Alltag dann auch tatsächlich den Großteil deiner Arbeit irgendwie mit solchen

[7:54] Hardware nahen Sprachen? C, C++ oder ich weiß nicht, was es inzwischen anderes gibt. Go oder D

[7:59] oder ich weiß es nicht. Nicht mehr, nein. Früher hätte ich den Ansatz probiert zu wählen und habe

[8:05] ich aber inzwischen komplett abgelegt. Hat sich so im Laufe des Informatikstudiums ergeben, dass ich

[8:11] halt festgestellt habe, dass mit dem Kenntnisstand, den ich vorher erlernt hatte, ich in der angewandten

[8:17] Informatik relativ wenig Chancen habe, dass das alles so funktioniert, wie ich mir das vorstelle

[8:21] und wie ich das brauche. Und habe dann an den Problemen gearbeitet und das Ganze hat bei mir

[8:26] auch angefangen mit Clean Code. Dass ich da angefangen habe zu lesen, habe gedacht so irgendwie

[8:31] da muss es noch mehr geben. Und darüber hinaus hat sich das Ganze weiterentwickelt und sich

[8:39] doch ziemlich vertieft. Wenn jetzt das Informatikstudium auch jetzt einem nicht unbedingt die

[8:43] Chance bietet, jeden Tag zu programmieren. Aber es ist halt irgendwas, was man nach der Uni machen

[8:48] muss. Und über die Schiene bin ich dann wirklich zur Softwareentwicklung und zum Engineering

[8:54] gekommen und nicht nur zum reinen Codeschreiben. Aber wenn du Code schreibst, womit schreibst du

[9:01] den Code heutzutage dann am liebsten? Gibt es da so eine Favorite-Sprache von dir?

[9:05] Ja, sie hat mich inzwischen als Lieblingssprache etabliert. Also inzwischen ist es C Sharp, was

[9:11] halt den Grund hat, dass wir aufs .NET Framework angewiesen sind. Es wäre die Möglichkeit damals

[9:18] im Unternehmen gewesen auch Java zu programmieren, aber es war alles sehr .NET lastig und dann habe

[9:23] ich mich danach gerichtet. Und deswegen bin ich dann auch bei C Sharp geblieben und inzwischen,

[9:29] ja die Lieblingssprache hat auch was mit dem Kenntnisstand zu tun meiner Meinung nach. Es

[9:33] fällt mir halt einfacher in C Sharp zu schreiben als in vielen anderen Sprachen, weil es einfach

[9:38] regelmäßig gemacht wird und eben nicht so nur mal hin und wieder. Klar, geht man mal hin und spielt

[9:44] mit anderen Programmiersprachen, aber ich würde sagen, die aktuelle Lieblingssprache ist doch schon

[9:49] C Sharp. Okay, das kann ich gut nachvollziehen. Also ich persönlich finde die auch einfach super

[9:54] cool und ich glaube die nächste, die bald rauskommt, die nächste Version ist glaube ich die Sieben,

[9:58] wenn ich es richtig weiß. Und da sind ja auch schon wieder ein paar richtig geile neue Features

[10:02] drin und man sieht ja einfach auch, dass die richtig krass weiterentwickelt wird auch und

[10:05] richtig viele neue Features reinkommen. Von daher kann ich gut nachvollziehen die Entscheidung.

[10:09] Ja, ich denke, was halt eine gute Entscheidung war, ist die ganze Nummer, die Microsoft gerade

[10:14] fährt in Sachen Core, also Cross-Plattform-Development. Das wird sich noch was entwickeln müssen,

[10:20] aber das ist auf jeden Fall interessant und man sollte da auf jeden Fall mal ein Auge drauf haben.

[10:24] Und der Vorteil ist halt, dass sie wirklich gesagt haben, wir bleiben bei der Sprache und

[10:28] haben nicht irgendwas Neues entwickelt. Ich sag mal für alle, die ein bisschen was Neues machen

[10:32] wollen und da, ja ich sag mal, trotzdem im .NET-Framework oder bei Microsoft bleiben wollen,

[10:37] ist natürlich jetzt F-Sharp, ich sag mal, geht natürlich jetzt dann in die Richtung, was jetzt

[10:42] gerade hip ist. Also ich denke, das ist nicht verkehrt, weil man bleibt halt irgendwo bei Visual

[10:49] Studio, man bleibt bei Microsoft, man kennt die Gegebenheiten und man muss sich nicht auf was

[10:53] komplett Neues konzentrieren und es neu erlernen. Das macht die Sache im Umstieg immer einfacher

[10:59] und deswegen sind halt so Sprachen wie Java oder C-Sharp meiner Meinung nach einfach momentan sehr

[11:04] interessant. Klar lässt sich natürlich über .NET auch C++ schreiben, aber halt Managed Code,

[11:12] also ich weiß jetzt nicht, ob das dann unbedingt einen Unterschied zu C-Sharp macht, den Overhead,

[11:16] den ich dann wieder mitschleppe. Also insofern, und C-Sharp ist natürlich auch eine der moderneren

[11:20] Sprachen, also die Klammersetzung ist übersichtlich. Das ist in einer Sprache wie Objective-C halt ein

[11:26] Riesenvorteil. Ja, also ich denke, ich meine, alternativ kann man bei uns auf der Arbeit auch

[11:32] mit Visual Basic arbeiten, wer das unbedingt möchte und es gibt halt viele ältere. Nicht

[11:37] VB6, nicht Visual Basic, ich möchte es bitte nicht tun. Ja, aber es ist für viele, die schon,

[11:44] ich sag mal, ein paar Tage älter sind, ist das auf jeden Fall eine Alternative, weil die darin

[11:49] Ewigkeiten geschrieben haben und die wollen das nicht unbedingt ablegen. Ja, ist klar,

[11:54] man bringt ja auch dann, wenn man Jahre damit hinzugebracht hat, auch eine gewisse Erfahrung

[11:57] mit und wenn ich jetzt wieder umsteigen muss auf eine andere Sprache, wo ich die vielleicht auch

[12:00] nochmal neu lernen muss oder Sachen ganz anders denken muss, klar, das ist erstmal für Leute

[12:04] vielleicht auch ein bisschen schwieriger. Ja, genau. Ich meine, das hat natürlich eine relativ

[12:09] flache Lernkurve. Viele haben irgendwann mal mit Visual Basic for Applications in Excel angefangen,

[12:15] arbeiten sich dann weiter über VB6, bevor sie merken, dass das gar nicht objektorientiert ist

[12:19] und landen dann nachher bei Visual Basic. Also ja, ich glaube, der Einstieg ist nicht schlecht

[12:25] und von daher der Umstieg dann nachher nach C Sharp, der fällt den meisten dann gar nicht

[12:29] mehr so schwer. Okay, klasse. Ja, dann haben wir, glaube ich, mit C Sharp auch schon den richtigen

[12:37] Einstieg gefunden, wenn ganz viele Entwickler da draußen, die auch mit .NET anarbeiten,

[12:41] werden natürlich auch bei der Arbeit mit C Sharp die Anforderung haben, irgendwie Daten aus einer

[12:45] Datenbank zu holen oder die da reinzuschaufeln und das soll ja eigentlich unser großes Thema

[12:49] heute sein, nämlich objektrelationale Mapper. Und wenn ich richtig weiß, ist so das Ding,

[12:55] was man mit .NET heutzutage so benutzt, das vom Hersteller selbst, nämlich das Entity Framework,

[12:59] aber es gibt bestimmt auch noch andere Implementierungen davon, aber vielleicht

[13:03] fangen wir ganz einfach erstmal an. Kannst du mal so grob erzählen, was überhaupt ein ORM ist und

[13:07] wofür man das braucht? Man braucht den ORM, um das Problem der Persistenz zu lösen, sage ich mal,

[13:15] und er verbindet die relationale Welt mit der objektorientierten Welt. Das heißt,

[13:21] die Datenbank, die aus der relationalen Welt kommt, muss in irgendeiner Form die Sprache sprechen,

[13:27] die die objektorientierte Welt spricht, um es mir einfacher zu machen. Normalerweise ist es umgekehrt,

[13:34] wenn ich ein SQL Statement verpacke oder mich mit der Persistierung auf der Seite der Programmierung

[13:40] beschäftige, richte ich mich nach der Datenbank und in diesem Fall übernimmt ein ORM das Verhandeln

[13:45] zwischen den beiden. Das heißt, ich brauche mich weniger mit der Persistierung an sich zu

[13:50] beschäftigen, sondern das übernimmt dieser Mapper. Ich sage mal, das ist auf jeden Fall so die grobe

[13:56] Beschreibung und er hat halt den Vorteil, dass er dann sämtliche Sprachfeatures meiner Sprache

[14:00] unterstützt und ich deswegen doch verhältnismäßig mit verhältnismäßig wenig Aufwand Daten in die

[14:07] Datenbank oder aus der Datenbank rauskriege. Und wenn jetzt dieser Mapper da irgendwie was

[14:13] übersetzt, was genau übersetzt er denn da? Also wir haben irgendwie Objekte in unserer

[14:17] objektorientierten Sprache und wir haben Tabellen zum Beispiel in der relationalen Datenbank, aber

[14:21] was genau macht der Mapper jetzt eigentlich für mich? Der Mapper sorgt dafür, dass die Tabelle

[14:26] nachher eine Abbildung im Code ist. Das heißt im Klartext, die Tabelle wird nachher als Klasse

[14:32] dargestellt und das hat halt den Vorteil, dass ich mit einem Objekt arbeiten kann, anstatt dass

[14:37] ich mit einzelnen Zeilen oder etwas ähnlichem arbeite. Und ja, es vereinfacht einem halt massiv

[14:46] das Arbeiten damit. Zusätzlich übernimmt der ORM die Kommunikation zur Datenbank. Das heißt,

[14:50] ich brauche mich nur um wenige Details kümmern und ich habe natürlich nachher den Vorteil,

[14:56] dass ich das im Prinzip über mehrere Projekte übernehmen kann. Also wenn ich mich damit einmal

[15:02] zurechtgefunden habe und das einmal für mich implementiert habe, kann ich sowas halt wieder

[15:07] verwenden und das ist natürlich immer was, was wir wollen. Kann man so ganz einfach sagen,

[15:12] um so eine Art Beziehung herzustellen, eine Klasse in meiner Objektorientierung entspricht vielleicht

[15:17] einer Tabelle und ein Objekt würde dann halt eben einem Datensatz in der Tabelle entsprechen?

[15:22] Genau, deswegen macht es mir die Sache deutlich einfacher, weil ich halt mit einem Objekt arbeite

[15:28] und nicht mit Zeilen in einer Datenbank, die ich dann nachher irgendwie mühsam zurückschreiben

[15:32] muss und wo ich wahnsinnig aufpassen muss. Und das, was ich vorhin gesagt habe, die Sprachfeatures,

[15:37] also in dem Fall kommt jetzt das zu tragen, was du gesagt hast. Ich kann halt meine Objekte in

[15:42] irgendwelchen Listen sortieren und kann damit arbeiten und sie entsprechend verwalten. Und

[15:48] damit habe ich halt sämtliche Sprachfeatures, die mir meine Sprache bietet, relativ einfach

[15:54] zur Hand und muss nicht hingehen und muss mühsam mir die Daten aus der Datenbank ziehen und muss

[15:58] sie dann probieren, dass ich sie so aufbereite, dass sie eben in eine Liste passen. Und diese

[16:03] Arbeit wird vom ORM übernommen und das ist einfach eine wahnsinnige Arbeitserleichterung und vor allem

[16:08] natürlich vermeide ich so auch massiv Fehler. Okay, heißt das dann so, dass ich als Entwickler

[16:14] eigentlich gar nicht mehr so genau wissen muss, wie die Datenbank im Hintergrund funktioniert

[16:17] oder zum Beispiel auch auf SQL komplett verzichten kann, weil das Framework für

[16:21] mich komplett übernimmt? Nein, das stimmt nicht. Ich hätte jetzt mal gesagt, das kann man vielleicht

[16:25] zwei, drei Fragen später beantworten, weil das natürlich so ein großes Thema ist, wenn man

[16:30] darüber redet, was ist einfach für mich und bequem und was ist möglichst performant. Damit sind zwei

[16:38] völlig verschiedene Dinge und da muss man ziemlich exakt differenzieren. Also im Grunde genommen ist

[16:43] es erstmal eine Arbeitserleichterung, aber es kommt natürlich irgendwo der Punkt, wo ich im

[16:48] Zweifelsfall in das System eingreifen muss und dann reicht der ORM nicht mehr aus oder dann

[16:54] sollte ich zumindest merken, an manchen Stellen, ich brauche jetzt eine andere Lösung, um das

[16:58] Problem zu behandeln. Okay, gut, das sind dann wohl eher so, ich sag mal, etwas fortgeschrittenere Fragen,

[17:06] dann schieben wir das Thema noch ein bisschen nach hinten, aber dann fangen wir vielleicht noch mal

[17:08] von vorne an. Also wissen jetzt, was ein ORM ist und wofür man das auch einsetzen kann, macht also

[17:12] meine Programmierung und die Arbeit mit der Datenbank ein bisschen einfacher. Gibt es da

[17:17] so ein paar bekannte Namen, vielleicht auch im .NET-Umfeld? Also Entity Framework hatte ich schon

[17:21] gesagt. Was benutzt du denn zum Beispiel für ein konkretes ORM? Also wir benutzen konkret auch

[17:26] Entity. Wir haben es mal mit nHibernate probiert, was ja ursprünglich aus der Java-Welt kommt und

[17:32] das Entity Framework hat einfach den kolossalen Vorteil, dass da eine Menge Entwickler hintersitzen,

[17:37] die was tun. Das wird stetig weiterentwickelt, es gibt eine Menge Informationen rundherum und jetzt

[17:43] kommt es natürlich immer auf die Firma an. Je nachdem, was die Firma für Verträge mit anderen

[17:48] Firmen hat oder wie ich an Software rankomme, hat es natürlich immer den Vorteil, dass ich

[17:53] im Zweifelsfall einer großen IT-Abteilung schnell erklären kann, dass ich etwas von Inhouse von

[17:57] Microsoft brauche. Das ist immer einfacher, als wenn ich irgendwas Externes implementieren möchte,

[18:02] weil ich das dann im Zweifelsfall durch irgendwelche Security-Prozesse genehmigt

[18:05] lassen muss und so weiter. Also insofern, das hat für uns den großen Vorteil. Wie gesagt,

[18:11] nHibernate ist eine Alternative. Funktioniert im Prinzip genauso. Es hat ein paar Vorteile,

[18:17] es hat aber auch ein paar Nachteile, die sehr im Detail sind meiner Meinung nach. Also ich würde

[18:23] sagen, wenn jemand damit anfangen möchte, ist das Geschmackssache. nHibernate hat halt den Vorteil,

[18:28] dass wenn man damit zurechtkommt, kommt man natürlich in der Java-Welt auch zurecht,

[18:31] weil es im Prinzip das Gleiche ist. Für die Java-Welt kenne ich noch, zumindest vom Reden,

[18:37] Express-Link habe ich selber noch nie ausprobiert, aber ich würde mal sagen,

[18:41] das sind auch so die drei großen. Also Hibernate, egal ob für die Java-Welt oder die Microsoft-Welt.

[18:47] Das Entity-Framework in der Microsoft-Welt ist auf jeden Fall das Größte meiner Meinung nach und

[18:53] hat auch den Vorteil, dass es inzwischen auch als Core-Variante gibt. Zwar, ich glaube,

[18:57] nur in einer relativ geringen Version, aber funktionieren tut es schon. Also für Cross-Plattform-Development

[19:03] ist es halt auch da und ich brauche mich nicht umgewöhnen. Das ist halt so ein bisschen der

[19:07] gleiche Vorteil, den ich bei Hibernate habe, wenn ich halt mit zwei verschiedenen Sprachen arbeite.

[19:11] Ist also nur mal ganz allgemein, alles was du gesagt hast, ist Open-Source,

[19:17] beziehungsweise wird von Microsoft einfach im .NET-Framework bereitgestellt oder gibt es da

[19:21] auch irgendein kommerzielles Werk, was man kaufen muss?

[19:23] Ne, das Entity-Framework ist frei. Es war ursprünglich mal im .NET-Framework enthalten,

[19:29] ist dann mit, ich weiß nicht genau, ob es Version 2 war, ist es dann, glaube ich,

[19:33] rausgenommen worden und läuft einzeln, aber wird von Microsoft weiterentwickelt. Es muss also

[19:42] nachinstalliert werden und es kommt nicht direkt mit dem Framework. Es gibt schon mal so Fälle,

[19:46] dass es mit Visual Studio mit installiert wird. Also ich kenne auf jeden Fall Leute,

[19:53] die das behaupten. Ich selber habe das noch nie gehabt, deswegen, es ist auch komplett einzeln,

[19:58] es gehört nicht zum .NET-Framework dazu.

[20:02] Okay. Ja, dann kann ich das ja so mal mit der Java-Welt vergleichen. Also, da wäre

[20:06] vielleicht die Alternative, also Hibernate, klar, ist natürlich auch eine konkrete

[20:09] Implementierung. In Java EE gibt es den Standard JPA, also die Java Persistence

[20:13] API und das ist quasi die Schnittstelle so eines ORMs und da ist es auch so, dass

[20:18] es erstmal in der Standard-Java-Variante nicht dabei ist, aber halt im Java EE hat

[20:21] man es dann und dann ist es aber auch genauso komplett kostenfrei. Also, wer

[20:25] so ein ORM benutzen möchte auf .NET und Java, offensichtlich kann man das einfach

[20:29] tun. Man muss nichts kaufen, sondern es ist einfach da. Man muss es vielleicht

[20:32] noch installieren, aber dann kann man es einfach ohne Probleme einsetzen.

[20:35] Ja, richtig. Aber per NuGet ist das in Visual Studio auf jeden Fall kein Problem.

[20:40] Ja, das glaube ich. Genau. Ja, was du auch sagtest, schwierig zu erklären oder durch

[20:48] die Instanzen zu kriegen, wenn man irgendeine Open-Source-Framework nimmt, wie

[20:50] Hibernate zum Beispiel. Das ist bei uns genau das Gleiche. Also, wir haben auch

[20:53] strategisch entschieden, wir setzen einfach auf den Java EE-Standard, weil wir

[20:57] einfach hoffen, dass der am langlebigsten ist und da muss man halt nicht irgendwem

[21:00] erklären, warum man jetzt zum Beispiel konkret das Produkt Hibernate benutzt und

[21:03] nicht einfach einen Java-Standard. Und da kann ich natürlich nachvollziehen und

[21:06] .NET würde ich wahrscheinlich mit diesem Hintergrund auch mich fürs Entity-Framework

[21:10] entscheiden, weil ich halt weiß, dass da steckt ein großer Hersteller hinter, der

[21:14] das auch wirklich aktiv weiterentwickelt. Ja, vor allem hat er ein Interesse daran.

[21:17] Das ist mir ganz wichtig. Also, jede Open-Source-Software ist immer gut und

[21:22] ist immer eine tolle Idee, aber das Problem ist halt, wenn die Entwickler

[21:26] irgendwann aus irgendwelchen Gründen, sei es privater Natur, dann irgendwann

[21:30] wegbrechen, ist es immer schwierig, diese Produkte weiterzuentwickeln und manchmal

[21:33] entwickeln die sich dann, wenn sie es denn werden, in eine ganz andere Richtung

[21:36] plötzlich weiter. Und wenn einem das dann nachher in irgendwelchen Projekten wieder

[21:40] auf die Füße fällt, ist das immer schlecht. Also, ich bin schon der Meinung,

[21:45] dass in Hibernate eine Daseinsberechtigung hat und dass es auch

[21:48] ein gutes Framework ist, das man nutzen kann. Das Entity-Framework erleichtert

[21:53] einem halt bei den gewissen Gegebenheiten, wie in großen Unternehmen

[21:57] einfach das entwickeln. Man muss sich nicht darum kümmern, dass man das

[22:01] erst noch ge-blueprinted kriegt oder wie auch immer der Prozess heißt in der

[22:06] eigenen Firma. Es ist bei dem Entity-Framework so, ich habe da den ein oder anderen

[22:11] Screencast schon mal dazu gesehen, aber das ist ja noch nicht eingesetzt. Ich glaube, es ist

[22:15] doch sogar so, man kann sich mit so einem SQL-Server von Microsoft, also dann hat man

[22:18] halt wirklich auch den ganzen Stake auf Microsoft, aber wenn man das nutzt, kann

[22:20] man sich, glaube ich, mit Visual Studio direkt mit der Datenbank verbinden und

[22:23] zieht irgendwie seine Tabelle da rein und dann wird da automatisch eine Klasse

[22:26] erstellt. Ist das wirklich so schön integriert?

[22:28] Ja, es hat sich wahnsinnig entwickelt über die Versionen. Ich kann jetzt ehrlich

[22:32] gesagt nicht zu jeder Version sagen, was sich wo geändert hat, aber ja, Microsoft

[22:37] setzt natürlich immer viel auf diese Designer-Varianten. Das ist immer viel

[22:43] Spielerei und viele, gerade so Screencasts, sind natürlich darauf ausgelegt, dass

[22:47] man binnen zehn Minuten irgendetwas herstellt. Microsoft bietet genau wie

[22:53] jeder andere Datenbankanbieter natürlich irgendwelche Beispieltabellen an, die sich

[22:56] immer wieder hernehmen lassen für sowas und bei denen das auch alles

[22:58] funktioniert. Ich glaube, zum Lernen ist das auf jeden Fall eine ganz gute Sache.

[23:02] Man kriegt halt schnell ein Ergebnis und kann mal sehen, was passiert. Aber

[23:05] grundsätzlich würde ich halt stark davon abraten, einen Designer zu verwenden,

[23:11] weil einfach zu viel im Hintergrund gemacht wird, was ich überhaupt nicht mitkriege.

[23:14] Da hat sich auch ein bisschen was der Trend gewandelt bei Microsoft. Also das

[23:19] war mit den Designern immer ein großes Thema. Das geht aber inzwischen immer mehr

[23:23] in Richtung Code-first und wo es dann halt wirklich darum geht, die Klasse als

[23:27] Code zu implementieren und nicht als Designer. Und ich halte das persönlich

[23:32] auch für das Bessere, weil man den besseren Überblick hat. Der Designer hat

[23:36] halt alle Tabellen und auf den ersten Blick sieht das alles ganz wunderbar aus.

[23:39] Aber spätestens, wenn man dann die Properties jeder Zeile angucken muss,

[23:44] finde ich es nicht mehr übersichtlich. Da finde ich es im Code deutlich

[23:48] übersichtlicher und einfacher dargestellt.

[23:53] Das Code-first, das habe ich auch schon mal gehört, heißt ja im Prinzip nichts

[23:57] anderes als, ich fange erst mal an zu programmieren und mein Datenmodell

[24:02] ergibt sich aus dem Code. Richtig?

[24:04] Ja, genau. Also im Prinzip lege ich die Klassen an und die

[24:11] repräsentieren ja nachher meine Tabellen in der Datenbank. Und ja, ich schreibe

[24:17] halt nur, weiß ich nicht, simple drei Klassen und zum Schluss schreibe ich

[24:20] noch einen DB-Kontext, der das Ganze verwaltet und schon bin ich fertig und

[24:26] schon kann auch das Entity-Framework das, was ich geschrieben habe, auf der

[24:30] Datenbank persistieren und erstellt die Tabellen, so wie ich es im Code

[24:34] angelegt habe. Und anhand von Annotations kann ich halt hingehen und kann

[24:39] Primärschlüssel angeben und und und. Da gibt es auch Möglichkeiten, dass wenn man

[24:43] eine gewisse Syntax einhält, also der Klassiker ist halt so beim Schlüssel, dass

[24:47] man irgendwo das ID mit drinstehen hat im Namen, dass er das dann automatisch

[24:53] erkennt. Also da ist das schon eine ziemlich gute Sache. Und für neue

[24:58] Projekte ist das auf jeden Fall das Beste, was ich empfehlen kann, hinzugehen und

[25:02] sich sein Datenbankmodell aufzuzeichnen und es dann in Code zu

[25:06] implementieren. Und es hat halt wirklich den Vorteil, man schreibt eine Klasse

[25:11] nach der anderen und es ist einfach extrem übersichtlich. Wenn man die dann

[25:17] noch im Projekt entsprechend verwaltet, das Namen stimmen und man sie auch in

[25:21] irgendeine Ordnerstruktur packt, dass es beisammen ist, dann wird man auch nach

[25:25] drei Jahren sofort wieder einen Einstieg kriegen, was man da hatte. Man muss nicht

[25:29] erst auf die Datenbank gehen und gucken, welche Tabellen habe ich und wie sieht

[25:33] das Ganze aus oder einen Designer öffnen. Es geht einfach so und es wird sich

[25:39] auch in der Klasse an sich nichts ändern. Das heißt, die werde ich in drei Jahren

[25:44] immer noch so öffnen können, weil es einfach ein Textdokument ist, während der

[25:47] Designer im Zweifelsfall mal wechselt und ich dann migrieren muss im

[25:51] Zweifelsfall oder sowas. Das geht dann immer theoretisch, automatisch, praktisch

[25:55] halt nachher nicht mehr.

[25:56] Und ich finde es auch einen konkreten Vorteil, man kann ja dann wirklich auch, wie

[26:01] man es heute eigentlich vielleicht machen sollte oder viele das machen, agiler

[26:04] entwickeln oder vielleicht sogar testgetrieben, indem ich einfach meine

[26:07] Klassen zuerst baue und gar nicht, ich sage mal in so einem klassischen

[26:10] Wasserfallmodell, so eine riesen Entwurfsphase, wo ich mein komplettes

[26:14] Datenmodell irgendwie aufzeichnen muss, habe, sondern ich kann wirklich als

[26:18] Entwickler mit dem anfangen, was ich täglich mache, nämlich Code, also Klassen

[26:22] schreiben und im Hintergrund kümmert sich irgendwer um die Persistenz und ich

[26:26] kann dann auch zum Beispiel sehr dynamisch ja mein Datenmodell durchaus

[26:28] anpassen, wenn ich feststelle Mensch, diese Beziehung passt so nicht, dann

[26:31] ändere ich das auf Codebene und das Framework, schwupp, generiert mir einfach

[26:34] die Tabellen im Hintergrund neu, richtig?

[26:36] Ganz genau. Und ich habe halt noch den Vorteil, dass ich über die Konsole im

[26:41] Prinzip meine Tabellen aktualisieren oder migrieren kann auf die Datenbank

[26:45] und das Framework, das Entity Framework schreibt gleichzeitig noch, liegt es

[26:49] eine Tabelle an mit Versionen. Das heißt, ich habe gleichzeitig noch eine Versionskontrolle drin.

[26:53] Das wird, ich arbeite jetzt nicht mit dem Designer, aber das wird für den

[26:57] wahrscheinlich auch gelten, aber ich kann halt dadurch relativ ungehemmt meine

[27:01] Tabellen ändern und kann halt feststellen, das funktioniert nicht und

[27:03] kann es wieder rückgängig machen und das ist natürlich eine super Sache

[27:07] gegenüber der Klickerei auf einer Datenbank und das Zusammenstellen von

[27:12] Tabellen und nachher das ganze Probieren rückgängig zu machen.

[27:16] Ja, es mag für einen Datenbank-Administrator wahrscheinlich auch kein Problem sein, dass

[27:20] der sagt, da gibt es auch Tools für, bin ich mir sicher. Ja, nur für uns als

[27:26] Softwareentwickler, wir sind keine Datenbank-Administratoren, also irgendwo

[27:29] ist halt der Cut und irgendwo ist es auch gerechtfertigt, dass es einen

[27:31] Datenbank-Administrator gibt, der sowas regelt und so kann ich relativ autark

[27:36] arbeiten und ja, kann die Vorteile des Frameworks nutzen.

[27:42] Das heißt, wenn ich jetzt als Entwickler anfange, dann mache ich mir schon, das

[27:45] finde ich auch ganz gut, wie du es auch gesagt hast, erst mal grobe Gedanken über

[27:48] mein Datenmodell. Ich fange nicht einfach wirklich bei null an, sondern ein

[27:50] bisschen im Hintergrund muss ich ja schon auf was hin steuern, sage ich mal, aber

[27:54] wenn ich jetzt meine erste Klasse fertig habe im Entity Framework, hast du jetzt

[27:57] gerade schon gesagt, entweder ich halte mich an so ein paar Konventionen, also

[28:00] zum Beispiel einen Schlüssel irgendwie ID nennen oder ich kennzeichne für das

[28:04] Entity Framework irgendwie, was sie jetzt mit oder was es jetzt mit dieser Klasse

[28:07] machen soll. Wie sieht das dann konkret aus, was mache ich da?

[28:10] Naja, im Prinzip ist es so aufgebaut, dass ich in meiner App-Config ein

[28:15] Connection-String haben muss. Dieser Connection-String, den habe ich im

[28:19] Prinzip immer, ob ich den jetzt im Code implementiere, wenn ich reines SQL mache

[28:22] und sage, ich will das als Objekt erstellen oder ob ich das halt in einer

[28:27] XML-Datei gespeichert habe oder ähnliches. Den braucht er dafür, der wird

[28:33] vom Datenbank-Kontext verwaltet. Der Datenbank-Kontext ist im Prinzip auch nur

[28:36] eine Klasse und diese Klasse repräsentiert die Datenbank. Er baut die

[28:41] Verbindung auf, er baut die Verbindung ab, er sorgt für das Zurückschreiben der

[28:44] Daten. Das heißt, dieser DB-Kontext verwaltet meine Klassen oder meine

[28:50] Entities und sorgt dafür, dass die Datenbank-Verbindung geöffnet wird,

[28:56] geschlossen wird, Daten zurückgeschrieben werden und so weiter.

[28:59] Also nachher im Programm-Code selber arbeite ich nur noch mit dem DB-Kontext

[29:04] oder ich abstrahiere das Ganze durch irgendein Data-Access-Layer, dass ich halt sage,

[29:09] ich möchte irgendwo flexibel bleiben und möchte im Zweifelsfall mal das Entity-Framework

[29:12] gegen was anderes austauschen. Dann kann ich das Ganze natürlich eine

[29:16] Stufe abstrahieren, aber es läuft halt wieder alles zurück auf diesen DB-Kontext,

[29:21] der im Zweifelsfall die Arbeit zwischen meinem Objekt und zwischen der

[29:29] Datenbank regelt. Das heißt, er nimmt mir die Arbeit, die ich sonst hatte, die ich

[29:35] per Hand gekodet habe, einfach ab. Und wie kann man sich das konkret vorstellen?

[29:39] Also guckt jetzt zum Beispiel einfach in die Klasse rein und legt für jedes

[29:42] Attribut, was es da gibt, eine Spalte an. Müssen zum Beispiel die Attribute

[29:45] irgendwie public dafür sein oder haben die irgendwelche Restriktionen?

[29:48] Ja, die sind public, selbstverständlich, damit ich halt drauf zugreifen kann von

[29:53] überall. Ansonsten haben die nicht wirklich Restriktionen. Das kommt nachher

[29:58] darauf an, wie komplex mein Datenmodell ist. Also ich kann an Annotations eine

[30:01] ganze Menge machen, aber um den simplen Einstieg zu bekommen, muss ich mich um

[30:06] sowas erst mal nicht kümmern. Also ich kann relativ schnell damit

[30:10] loslegen. Ein paar Zeilen Code reichen und komm mit an die Datenbank und es läuft schon.

[30:16] Und die Konvention wäre dann zum Beispiel, dass er eine Tabelle anlegt,

[30:20] die exakt so heißt wie die Klasse und die Spalten heißen dann so wie die

[30:23] Attribute? Ja, zum Beispiel ist von der Grundeinstellung her richtig. Man kann

[30:31] das Ganze natürlich da eingreifen durch wie gesagt Annotations. Man kann auch im

[30:35] DB-Kontext sagen, der Klassiker ist so die Pluralisierung. Das heißt, wenn jetzt

[30:40] eine Tabelle im Singular erstellt wird und wird sie dann nach auf die Datenbank,

[30:45] wird sie da pluralisiert. Das ist im Deutschen unpraktisch. Im Englischen

[30:48] funktioniert das gut. Wer natürlich probiert, das Ganze in Deutsch zu machen,

[30:52] der wird natürlich merken, das hört sich ein bisschen komisch an. Aber kann halt an

[30:57] jeder Stelle eingegriffen werden und entweder durch die Annotations an sich

[31:00] in dem Entity, das heißt über der entsprechenden Spalte oder der ganzen

[31:04] Tabelle kann ich Annotationen angeben, wo ich vom Standard abweichen möchte.

[31:08] Oder halt im DB-Kontext kann ich auch gewisse Sachen, die halt vom DB-Kontext,

[31:15] wie zum Beispiel das Schreiben der Tabellen in die Datenbank und dadurch das Pluralisieren,

[31:19] da kann ich natürlich dann eingreifen. Wobei die Standardeinstellungen, die Microsoft so

[31:24] vorsehen, meiner Meinung nach für die meisten Fälle erstmal in Ordnung sind.

[31:29] Also ich würde nicht zu weit von sowas abweichen.

[31:32] Das ist ein gutes Stichwort. Ich vergleiche das immer gerne mit Ruby on Rails zum Beispiel.

[31:38] Da ist der ORM, der da active irgendwas heißt, ich weiß nicht mehr, so stark integriert.

[31:45] Wenn man sich da einfach an die richtigen Konventionen hält, dann funktioniert das

[31:48] einfach und ich kann sogar so eine Ruby-Klasse dann aufmachen und sehe nicht mal mehr die

[31:52] Attribute da drin und das funktioniert einfach alles. Es ist super gut integriert mit der

[31:55] Datenbank und das ist schon so ein bisschen Magie, sage ich mal.

[31:59] Und da finde ich es eigentlich ganz gut, wenn man dann zum Beispiel in Java oder hier auch eben in

[32:02] .NET noch mal wenigstens irgendwie ein bisschen was in der Klasse sieht, dass es irgendwie einen

[32:06] Bezug zum Entity-Framework hergestellt werden kann.

[32:10] Ja, wie gesagt, man kann das ziemlich weit beeinflussen, wenn man möchte.

[32:14] Das ist nachher halt eine Frage, wie tief bin ich da drin und wie schwierig ist mein Datenbankmodell?

[32:20] Da liegt es eigentlich eher. Also ich sage mal, für die meisten Sachen brauche ich es definitiv nicht.

[32:27] Und wenn, ist das halt einfach eine Entwicklung. Da kommt mir halt wieder das Entity-Framework zugute,

[32:31] dass ich sagen kann, ich fange mit einem leeren Blatt Papier an, zeichne mein Datenmodell,

[32:36] erstelle die Klassen, schicke alles auf die Datenbank und gucke mir das nachher an.

[32:41] Und während ich mit meinem Projekt arbeite, stelle ich fest, ich müsste vielleicht dieses oder jenes ändern.

[32:47] Und dann kann ich im Nachhinein halt noch mal in meine Klasse eingreifen und kann sagen,

[32:51] ich kann es dementsprechend ändern und so lerne ich das System kennen und stelle auch fest, ja, es geht alles.

[33:00] Es ist halt eine Frage, wie viel Zeit möchte ich investieren, um das zu ändern?

[33:04] Oder überlege ich mir vielleicht, ob die Standardkonvention nicht vielleicht doch die bessere Idee war?

[33:10] Auf jeden Fall, ja. Also bei Rails wird das ja ganz hoch gehalten.

[33:14] Da muss man wirklich, ich weiß nicht, durch tausend Ringe springen, um überhaupt vom Standard abweichen zu können.

[33:18] Ich finde das eigentlich auch genau richtig, weil es ja auch dann für Leute, die neu einsteigen ins Projekt,

[33:22] deutlich einfacher ist, das nachzuvollziehen.

[33:24] Weil man halt sieht, die Klasse heißt Auto, also heißt die Tabelle auch Auto.

[33:28] Und man muss halt nicht über ganz viele Annotationen gucken, wie es denn jetzt umbenannt wird oder wie auch immer.

[33:32] Also ich würde auch dringend dazu raten, sich an den Standard zu halten, auf jeden Fall, ja.

[33:36] Ja, es ist eigentlich immer eine ganz gute Idee, aber normalerweise haben Studenten, die von der Uni kommen,

[33:42] immer das Problem, dass sie eine Vorstellung haben, wie das Ganze aussehen soll und machen meistens das Problem schwieriger,

[33:49] als es eigentlich ist. Ja, das ist wirklich so.

[33:52] Und die fangen dann an, sich in Annotationen zu vertiefen, bis man ihnen dann erklärt, so, probier es mal ohne.

[33:57] Folge mal dem Standard und vielleicht änderst du was an deinem Datenmodell.

[34:00] Und dann kommen die recht schnell dahinter, dass sie feststellen, doch, doch, das ist schon die richtige Wahl.

[34:05] Aber es sind halt tausend Kleinigkeiten, die man auch ändern kann, wo ich sage, manches ist Kosmetik, manches ist sinnvoll.

[34:12] Für viele Sachen habe ich persönlich noch keine Anwendung gefunden.

[34:16] Also ich weiß nicht, ich finde es manchmal ein bisschen kurios.

[34:20] Ich bin der Meinung, es tut mir nicht weh, wenn in meiner Spalte irgendwo das Wort ID mit drin vorkommt und ich das Ganze im Camel Case schreibe.

[34:26] Dann finde ich, kann ich das besser lesen, als wenn das irgendeinen entsprechenden Namen hat und jemand als Annotation drüber schreibt, dass das die ID ist.

[34:34] Aber das ist vielleicht Geschmackssache oder Erfahrung, ich weiß es nicht genau.

[34:39] Aber ich denke so, manchmal ist es, glaube ich, auch, dass die Leute einfach nicht wissen, dass das geht, sondern dass sie es sich halt deswegen schwieriger machen.

[34:49] Also wenn man jetzt vom einfachen Fall ausgeht, wir haben eine Klasse und da werden die Attribute zu Spalten in der Tabelle und so, das ist ja okay.

[34:55] Was mich persönlich jetzt noch interessiert, wie handelt denn das Entity Framework jetzt Kardinalitäten?

[34:59] Also wenn ich sowas wie eine M2N-Beziehung habe oder eine 1-zu-N-Beziehung, muss ich da dann zum Beispiel mit solchen Annotationen arbeiten oder kriegt ihr das von alleine hin?

[35:06] Wenn zum Beispiel eine Klasse Student hat irgendwie eine Liste aller Kurse, die dieser Student besucht, kann das Entity Framework automatisch diese Beziehung herstellen oder muss ich zum Beispiel Annotationen dran packen?

[35:20] Nee, ich muss nicht zwangsläufig Annotationen dran packen. Das, was ich halt kann, dass ich halt eine Liste verwenden kann, also anstatt, dass ich als Datentyp sage, das ist ein Kurs vom Typ, weiß nicht, Integer von mir aus, dass der eine Nummer hat,

[35:34] sondern ich lade im Prinzip als Liste die ganze andere Tabelle nämlich darin auf und so habe ich eine Beziehung hergestellt.

[35:40] Das ist relativ einfach, also da brauche ich nicht viel machen. Da mag es Fälle geben, wo man also bei N-zu-N-Beziehungen, wo man eine Zwischentabelle braucht, man kann natürlich da mehr Aufwand betreiben.

[35:54] Das ist aber so von Fall zu Fall, ich sag mal unterschiedlich und je nach Datenmodell halt wieder abhängig.

[36:01] Aber der Klassiker, der Student besucht Kurse, das wäre der Kurs. Ich würde es über eine Liste machen und würde sagen, das ist eine Liste und irgendwas Generisches nehmen und im Prinzip die Kurse dem Studenten zuweisen.

[36:15] Also ich würde es auch so sehen, in Java wäre es dann so, dass man halt überall trotzdem noch eine Annotation dran packen muss und ihm sagen muss, wie die Beziehung ist, zum Beispiel one-to-many, many-to-many und so weiter.

[36:26] Und interessant wird es dann aus meiner eigenen Erfahrung immer dann, sobald ich an diese Beziehung auch noch Attribute hängen muss, also zum Beispiel Student besucht Kurs zu der und der Uhrzeit oder sowas.

[36:36] Würde man das dann in dem NC-Firmware auch mit einer echten Klasse für diese Beziehung lösen oder gibt es da noch andere Möglichkeiten?

[36:43] Also ich hätte es jetzt in dem Fall auch probiert mit einer Klasse zu lösen und ja, man kann mit Annotationen, wie gesagt, vieles probieren zu überschreiben, aber der erste Ansatz wäre halt immer, das ist keep it simple.

[36:56] Und würde sagen, ich suche mir irgendwas Schönes Generisches und gucke mal, ob ich das nicht damit verbunden kriege.

[37:02] Das ist immer der einfachste Weg und ich würde auch behaupten, in den meisten Fällen funktioniert das.

[37:07] Wer natürlich jetzt ein Datenmodell kriegt, was 20 Jahre alt ist und wo schon seit 20 Jahren dran rumgedoktert wird, der wird natürlich mit Annotationen spielen müssen ohne Ende.

[37:18] Aber ich probiere sowas halt immer möglichst zu vermeiden und bin halt der Meinung, irgendwann kommt auch so der Cut, wo man sagen muss, halt, bis hierhin und nicht weiter und wir probieren das jetzt mal neu aufzusetzen und zu migrieren, weil dann haben wir die nächsten Jahre uns die Arbeit auch deutlich vereinfacht.

[37:34] Und ja, wie gesagt, das Thema Annotationen ist wahrscheinlich ein ganzer Podcast für sich selbst.

[37:42] Gerade im Java Umfeld auf jeden Fall, da geht gar nichts mehr ohne Annotations, das ist der Wahnsinn.

[37:48] Sehr gut.

[37:50] Das heißt, wenn ich jetzt einsteigen will, ich fange mit ganz normalen Klassen an und wenn ich Beziehungen habe, nutze ich meine ganz normalen Datenstrukturen, die ich kenne, also was weiß ich, ein Set, eine List oder was auch immer und packe da die Sachen rein und dann drücke ich auf den Knopf und das Entity Framework persistiert mir das und dann muss ich mich eigentlich um die Datenhaltung gar nicht mehr so richtig kümmern.

[38:08] Oder muss ich doch irgendwann dann mal im Code auch wirklich sagen, Entity Framework, speichere jetzt bitte mal mein Objekt.

[38:14] Klar muss man dem Entity Framework sagen, speichere mal.

[38:17] Der Vorteil bei dem Ganzen ist, es geht halt alles über den DB-Kontext, bei dem ist die Schnittstelle IDisposable implementiert.

[38:26] Das heißt, ich kann mit einem simplen Using-Block, den mache ich auf, sage was ich möchte und eröffnet die Datenbank und schließt sie automatisch.

[38:33] Wenn ich das Ganze speichern möchte, also es wird erstmal lokal natürlich in den Cache geschrieben und irgendwann kommt der Punkt, wo ich sage und jetzt zurückspeichern und dann wird alles, was ich dann verändert habe, persistiert.

[38:45] Und dann genau an der Stelle taucht eben die Frage vom Anfang wieder auf, kann ich das immer machen oder habe ich damit Probleme?

[38:54] Und jetzt kommen wir zu dem Thema, brauche ich noch SQL? Ja, brauche ich.

[38:59] Weil wenn ich jetzt bei 10.000 Datensätzen einen Fleck ändern möchte, möchte irgendwas von 1 auf 0 stellen oder umgekehrt, dann ist das natürlich relativ unpraktisch, wenn das Entity Framework hingeht und erstmal einfach alles in den lokalen Speicher lässt.

[39:12] Also an der Stelle wäre es dann halt sinnvoll zu überlegen, allein so, wobei bei 10.000 Datensätzen wird es wahrscheinlich nicht mal stören, aber wenn es jetzt 100.000 oder mehr sind,

[39:21] ist es halt einfach, ein simples SQL-Statement zu schreiben und zu sagen, ab zur Datenbank und einfach nur diese eine Spalte ändern in jeder Zeile und damit ist es gut.

[39:32] Und ja, ich sag mal, da muss man ein Gefühl für kriegen im Projekt, an welcher Stelle kann ich was nutzen und jetzt sieht man halt ziemlich gut, dass durch diese Implementierung vom DB-Kontext das IDisposable den kolossalen Vorteil hat.

[39:50] Es ist total simpel für mich, es zu verwenden und ich muss mich um nichts kümmern.

[39:53] Ich kann Link to Entities benutzen in der Microsoft-Welt, was nichts Neues ist, was es schon vorher gab und was halt dem Compiler erlaubt, alles, was ich schreibe, zu kontrollieren, was bei meinem SQL-Statement nicht der Fall ist.

[40:09] Dafür ist das im Fall von 100.000 Zeilen vielleicht deutlich schneller und wenn das jetzt zeitkritisch ist, was ich mache,

[40:15] Dann ist das auf jeden Fall dann die Wahl zu sagen, ich mache ein SQL-Statement, dafür habe ich natürlich keine Unterstützung mehr von meiner Entwicklungsumgebung, die mir sagt, du, da hast du einen Schreibfehler drin oder sonst was.

[40:28] Da muss ich jetzt mal kurz nachhaken, das interessiert mich tatsächlich. Also das heißt, wenn ich jetzt so wirklich irgendeinen performanten SQL-Befehl absetzen will, würde ich das über so eine Schnittstelle machen, wo ich wirklich den SQL als String reingebe.

[40:41] Oder was du gerade sagtest, würde ich das dann halt mit Link to Entities machen. Das heißt, also dieser DB-Kontext, hat der noch irgendwie eine Möglichkeit, hardcoded SQL reinzuschmeißen oder mache ich das dann immer typisiert, auch zum Beispiel mit Link?

[40:55] Ja okay, das ist natürlich jetzt vom Projekt abhängig und von der Stelle. Also ich sage mal, hauptsächlich würde ich über den DB-Kontext gehen, aber ich habe natürlich auch die Möglichkeit, nochmal eine Verbindung im Hintergrund aufzubauen, die stört natürlich nicht.

[41:08] Ich sage mal, wenn ich es richtig mache, ist das okay, aber ob ich Link to Entities oder Entities to SQL verwende, das ist im Prinzip egal.

[41:16] Das Link to Entities ist in der Microsoft-Welt ein relativ großes Thema, weil man es an vielen Stellen einsetzen kann und ich halt eine gute Unterstützung von meiner Entwicklungsumgebung bekomme.

[41:25] Das lässt sich ganz gut lesen. Man muss sich mal an die Syntax einmal gewöhnt haben und dann ist es gut. Ich kann natürlich, wie gesagt, hardcoded SQL verwenden und dann muss ich allerdings im Projekt halt gucken, wie bringe ich das am besten unter.

[41:39] Ist denn das, also wenn ich jetzt mit dem Link to, oh Gott, wie hieß es jetzt? Link to Entities, ja. Das ist quasi wirklich Link, also in die Sprache auch integriert. Das ist also diese Standardschnittstelle, die Microsoft ja seit ein paar Jahren schon anbietet.

[41:53] Ich kenne es jetzt zum Beispiel aus der Java-Welt, da gibt es halt quasi eine eigene Sprache für die Abfragen. Die heißt dann nicht SQL, sondern JPQL, also die Java Persistence Query Language.

[42:03] Die sieht fast genauso aus wie SQL, ist aber nicht hundertprozentig gleich und da gibt es dann halt auch die Möglichkeit, das wirklich als Strings irgendwo reinzuschreiben, zum Beispiel eine Annotation an eine Klasse und dann packe ich da so eine Query rein.

[42:14] Aber mir geraust es dann immer irgendwie, weil eigentlich habe ich ja das OM, damit ich nicht irgendwie mit Strings rumhantieren muss, weil ich will ja eigentlich auf Objektebene arbeiten.

[42:22] Ja, genau.

[42:23] Und da fände ich es natürlich cool, wenn im Entity-Framework, wenn ich da wirklich mit dem Link arbeiten kann, also zu keiner Zeit irgendwie meine Typisierung aufgeben muss, ja.

[42:30] Ja, wie gesagt, muss ich halt nicht zwangsläufig, aber ich kann halt auch, wie das gerade in Java erklärt, das Entity-to-SQL nehmen.

[42:36] Ist halt auch so ein bisschen was, eine Abwandlung von SQL, also ist glaube ich nicht reines SQL, wenn ich das richtig weiß.

[42:41] Ah, okay.

[42:42] Und das kann ich halt nutzen, aber ich bin halt auch der Meinung, Link-to-Entities und der OM bieten mir im Prinzip alles, was ich brauche.

[42:52] Es gibt halt, wie gesagt, schon mal zeitkritische Sachen, wo man dann echt überlegt, ob man da nicht vielleicht einfach reines SQL benutzt.

[42:58] Von mir aus Entity-to-SQL, Entity-SQL oder reines SQL, das ist möglich, aber halt immer vom Projekt abhängig.

[43:08] Also es gibt halt so Punkte, wo ich sage, ich muss bin in so und so viele Millisekunden dieses und jenes gemacht haben.

[43:14] Da könnte natürlich der Overhead, den der OM bietet, einfach zu viel sein, auch wenn das vielleicht noch so gerade funktioniert.

[43:21] Aber ich auf der sicheren Seite sein möchte, dann kann ich das Ganze trotzdem noch umgehen und habe halt ein paar andere Möglichkeiten.

[43:28] Und ob das jetzt halt Entity-to-SQL ist oder ob das ein reines SQL-Statement ist, das ist dann, ich will jetzt nicht sagen gehüpft wie gesprungen.

[43:35] Da wird es wahrscheinlich auch Leute geben, die mal in den Nacken springen und sagen, das kannst du mir nicht sagen.

[43:40] Aber ich probiere oder wir probieren hauptsächlich auf den OM zu setzen und halt wirklich nur in Spezialfällen davon abzuweichen.

[43:49] Aber da ist halt genau der Punkt, den du gesagt hast, es gibt immer wieder Probleme, die kann ich einfach nicht immer damit lösen.

[43:56] Weil der OM ist ja nichts anderes, der macht ja nichts anderes, als das SQL selber zu schreiben, was du sonst früher gemacht hast.

[44:03] Und an der Stelle ist das halt wieder ein Wrapper um irgendetwas und in dem Fall ist der DB-Context sogar glaube ich ein Wrapper um,

[44:12] es gab früher DB, fällt mir jetzt gar nicht ein, wie es heißt, aber da liegt noch einer drunter und ich sage mal, der Komfort ist immer größer geworden,

[44:22] aber dafür habe ich natürlich immer mehr Overhead.

[44:24] Da gibt es ganz nette Vorträge zu dem Thema, wo Leute das halt wirklich mit Millisekunden untermauern, wie der Unterschied ist bei so unsviel Datensätzen.

[44:33] Das ist ganz interessant, das zu sehen und das zeigt halt, dass ich immer wieder gezwungen bin, im Zweifelsfall auf die Basics zurückzugreifen.

[44:41] Und deswegen sollte ich SQL können oder zumindest wissen, wie es geht.

[44:45] Man muss das vielleicht nicht in Perfektion können, weil auch da gibt es natürlich Horror-SQL-Sachen, die man zusammenstellen kann.

[44:53] Also ja, insofern, wie du es oben gesagt hast, SQL ist auf jeden Fall nötig.

[45:02] Okay, ja, das finde ich eine gute Aussage.

[45:04] Nicht umsonst ist es ja immer noch auch in den Abschlussprüfungen drin und fast in jeder schriftlichen Prüfung muss man was mit SQL machen.

[45:10] Finde ich auch richtig so, denn ich finde es auch immer wichtig, dass so Sachen, so Frameworks, die einem die Arbeit erleichtern und quasi eine Abstraktion bilden,

[45:18] dass man trotzdem versteht, was eigentlich dahinter passiert.

[45:20] Denn sonst kann man ja gar nicht einschätzen, zum Beispiel, wenn du mal wegen dieser 10.000 Datensätze updatest und das dauert fünf Minuten.

[45:26] Du verstehst ja gar nicht, warum das so lange dauert, wenn du gar nicht weißt, was im Hintergrund eigentlich auf SQL-Ebene passiert.

[45:30] Deswegen finde ich es auch wichtig, dass man das versteht.

[45:33] Ja, aber ich denke, genau da ist halt der Punkt, dass es halt für Auszubildende oder Studenten halt ein super Einstieg ist,

[45:39] weil die haben alle mal irgendwo SQL gemacht, auch wenn die das jetzt nicht sofort hinschreiben könnten.

[45:44] Und die fangen damit an und wissen, ich bin in meiner objektorientierten Welt, ich kann erstmal alles machen.

[45:51] Und wenn ich das Projekt dann an einen gewissen Punkt bekommen habe, wo der Point-of-No-Return eh schon überschritten ist,

[45:57] dann stellt man plötzlich fest, hier habe ich ein Performance-Problem.

[45:59] Wie kann ich jetzt eingreifen?

[46:01] Und dann muss man sich an das erinnern, was man mal gelernt hat in der Schule und sagen, jetzt fange ich an, das nochmal tiefer zu begreifen.

[46:07] Und dann ist es halt wieder sehr vom Fall abhängig.

[46:10] Ich finde, da kann man jetzt keine pauschale Aussage zu sagen, wie geht man das an, was ist das Beste.

[46:16] Das muss man von Fall zu Fall selber entscheiden, weil das halt ganz stark vom Datenmodell abhängt und von der Aufgabenstellung, die ich habe.

[46:24] Gibt es da in dem Entity Framework dann auch so eine Möglichkeit, wie, zeig mir jetzt mal als Debugging-Output zum Beispiel jedes SQL-Statement an,

[46:31] was er generiert, um das nachvollziehen zu können?

[46:33] Ja, kann ich machen. Ich kann das sogar direkt in eine Tabelle auf der Datenbank schreiben lassen.

[46:37] Also insofern kann ich dann halt nachher, weiß nicht, entweder schreibe ich noch ein zweites Programm, was mir das dann nachher anzeigt einfach.

[46:44] Oder ich mache irgendein Output-Fenster oder ich kann es an der Konsole teilweise anzeigen.

[46:48] Ich glaube, alles das, was er in die Datenbank schreibt, kann er auch genauso in der Konsole anzeigen.

[46:53] Also da ist Debugging-mäßig für gesorgt, dass das funktioniert.

[46:57] Und was ich halt eine sehr noble Sache finde, ist, dass das direkt, ohne dass ich was tun muss, eigentlich in der Datenbank landet.

[47:02] Also ich muss nur sagen, ja, hätte ich gerne.

[47:04] Und in dem Moment wird der ganze Debugging-Output in die Datenbank geschrieben.

[47:10] Und ich kann halt im Hintergrund, wenn ich das Programm jetzt das erste Mal live gehen lasse und es wird von Kollegen getestet,

[47:17] im Hintergrund, ohne dass ich da jetzt irgendwas schreiben muss und ein Programm, was das nachher ausliest, kann ich auf der Datenbank halt gucken,

[47:24] okay, zu dem und dem Zeitpunkt ist dieses und jenes passiert.

[47:27] Und dann kann ich das halt in Echtzeit sozusagen mitverfolgen, wenn ich es unbedingt möchte.

[47:33] Cool. Das fände ich gut.

[47:35] Also bei Java gibt es das auch. Ich kann einfach so einen Flag setzen und dann haut der mir alle SQL-Statements raus.

[47:39] Aber es ist dann teilweise so ein bisschen schwer, das nachzuvollziehen und das landet dann halt in irgendwelchen Log-Files.

[47:44] Aber wenn das quasi direkt in der Datenbank landet, das ist ja genau an dem Ort, wo ich eh suchen würde.

[47:48] Das fände ich natürlich cool.

[47:49] Es ist extrem praktisch, vor allem, dass man halt sagen kann, ich habe noch irgendein Logging-Framework mit drin und ich logge sowieso.

[47:59] An der Stelle, wo das Entity-Framework packt, brauche ich mich um das Logging eigentlich nicht mehr kümmern.

[48:05] Sondern es landet direkt in der Datenbank und ich kann dann halt nachher zusammenbauen,

[48:10] wenn ich sowieso mit einem Logging-Framework Logging in der Datenbank speichere, kann ich das halt nachher ganz gut mischen,

[48:16] weil ich halt wirklich einfach Tabellen habe, mit denen ich wieder arbeiten kann.

[48:20] Und das gibt nachher dann halt auch einen relativ netten Output, wenn ich den denn halt möchte.

[48:25] Also Fehlersuche, das geht schon einen Schritt drüber.

[48:29] Also es geht nicht nur Fehlersuche für Entwickler, sondern ich kann halt auch wirklich meinem Endkunden, der das haben möchte,

[48:34] recht viele Informationen bereitstellen, wenn ich das möchte und das auf einem einfachen Weg.

[48:40] Cool, ja, das stimmt.

[48:41] Ja, vielleicht sicherlich auch für so einen Datenbank-Administrator im Hintergrund, der mal gucken will,

[48:46] was macht denn der Entwickler oder beziehungsweise in diesem Fall jetzt das Framework da, warum habe ich so eine hohe Last oder so,

[48:50] kann er einfach mal eben die ausgeführten Statements sich nochmal angucken.

[48:53] Okay, von der Seite habe ich noch gar nicht betrachtet, aber du hast natürlich recht, ja.

[48:56] Also die hatte ich noch nicht auf dem Schirm.

[48:58] Ich hatte das jetzt eher aus meiner Swarte gesehen, was passiert und wo ich den Fehler habe.

[49:05] Ich muss sagen an der Stelle, dass die Informationen, die da rauskommen, die sind ziemlich reichhaltig

[49:11] und dass ich die in den meisten Fällen eigentlich gar nicht brauche.

[49:14] Also ich kann das nachher ganz gut filtern, weil ich sagen kann, also das, was das Framework halt macht,

[49:20] das ist halt der Vorteil, ich kriege ein wohlgetestetes Framework und das setze ich ein und das funktioniert in tausenden Applikationen schon.

[49:28] Und deswegen ist die Chance, dass da wirklich ein Fehler entsteht.

[49:32] Ich will nicht sagen, die ist tendiert gegen Null, aber die ist gering.

[49:35] Also wir haben damit auf jeden Fall wenig Probleme.

[49:38] Jetzt haben wir eher das Problem von vielen Datensätzen als von ultra komplexen Anwendungen.

[49:44] Ja, also ich glaube, da ist schon das, was im Entity Framework und Login drin ist, auf jeden Fall ausreichend für die meisten Fälle.

[49:55] Ja, da hast du natürlich völlig recht.

[49:57] Also die Frameworks, das sieht man natürlich, die sind ausgereift.

[49:59] Da steckt bei Microsoft sogar der große Anbieter dahinter.

[50:02] Das heißt, wenn man das einsetzt, kann man sich ziemlich sicher sein, dass der Code nachher auch funktioniert und keine Fehler drin sind.

[50:07] Aber hast du denn aus deiner Praxis jetzt vielleicht auch irgendwie ein paar Nachteile, die beim Einsatz von ORMs aufkommen?

[50:12] Nachteile?

[50:14] Ja, also da ich ein großer Fan des EF bin, habe ich da nicht so viele Nachteile.

[50:19] Also ich kenne aber Kollegen, die halt bei vielen Sachen sagen, dass mir der Aufwand zu viel ist am Anfang.

[50:24] Die sagen halt, also eine Datenbank-Connection, um gerade was abzufragen, da bin ich schneller, wenn ich ein SQL-Statement schreibe.

[50:30] Ja, das stimmt.

[50:32] Das ist aber meiner Meinung nach halt immer so ein Bastelprojekt und basteln sollte man nicht.

[50:38] Also man sollte halt schon vernünftig einen Code schreiben und auch getestet werden.

[50:41] Und wenn jemand die Zeit nicht hat oder zu faul ist, so ein Framework zu implementieren, dann hat er meistens auch keine Zeit für den Rest, wie Unit-Tests und all so ein Kram.

[50:51] Und an der Stelle würde ich sagen, das ist für mich auf jeden Fall kein Grund zu sagen, der Aufwand ist mir etwas zu viel, weil ich mit meinem SQL-Statement schneller bin.

[51:00] So richtige Nachteile hat man halt nur, sag ich mal, wenn es um Performance geht.

[51:06] Also wenn es halt wirklich um zeitkritische Sachen geht, mir fällt ja jetzt gerade nichts ein, aber je nachdem, wenn am Flughafen, ich sag mal, irgendein Flugzeug landet und ich muss wirklich in Millisekunden oder noch schneller antworten,

[51:18] dann mag das vielleicht in irgendeiner Form zu viel des Guten sein, aber ansonsten würde ich sagen, man kann es immer einsetzen.

[51:26] Ich habe da mit nur guter Erfahrung gemacht und kann jetzt nicht sagen, dass ich an irgendeiner Stelle ganz schlechte Erfahrungen hatte.

[51:32] Vielleicht kann es natürlich sein, dass je nachdem die Komplexität des Datenbankmodells das dann nachher irgendwo erschwert.

[51:40] An den Punkt bin ich auf jeden Fall noch nicht gekommen.

[51:43] Also ich kann es aus der Praxis sagen, auch bei unseren Azubis, wenn die das zum ersten Mal einsetzen, SQL können sie, ist so ein Standard, haben sie gelernt und mit dem Framework, da muss man sich halt erst mal einarbeiten.

[51:53] Das dauert natürlich auch, aber der Aufwand ist es auf jeden Fall wert, das würde ich sagen.

[51:57] Am Anfang, klar, dauert es vielleicht ein bisschen länger, weil man halt noch nicht so richtig verstanden hat, wie das Framework funktioniert, weil das ist das Hauptproblem, aber danach würde ich auch auf jeden Fall sagen, lohnt sich.

[52:07] Es ist wirklich eine tolle Geschichte, nimmt uns viel Arbeit ab, aber hast du dann vielleicht irgendwie einen Tipp?

[52:11] Muss man von Anfang an in so einem Projekt schon daran denken, dass man das mit einem ORM umsetzt, also muss man das irgendwie einplanen, architektonisch zum Beispiel, oder sage ich einfach, sobald ich irgendwie was mit der Datenbank mache, nehme ich das Entity Framework zum Beispiel?

[52:25] Ja okay, Architektur ist natürlich immer so ein wichtiges Thema und da gibt es ganze Bücher drüber, die natürlich dir sagen, wie du es am besten machst.

[52:34] Ja, wenn das Projekt ein bisschen größer wird, sollte man auf die Architektur achten, schon alleine aus dem Grund, dass sich nachher jemand wieder drin zurecht finden könnte in drei Jahren, das ist immer so ein ganz großes Thema.

[52:47] Wenn ich so ein kleines Projekt habe, was irgendwelche Kleinigkeiten nur die Datenbank speichert, dann kann ich das auch relativ salopp programmieren und kann sagen, ich schmeiß das erstmal alles in ein Projekt rein und das funktioniert.

[53:00] Mit der Größe des Projekts merke ich relativ schnell selber, an der Stelle funktioniert es überhaupt nicht, da muss ich was ändern und da muss ich was in meiner Projektstruktur ändern und genau so ist es da auch.

[53:09] Wenn man sich irgendwelche Screencasts anguckt oder auch Video to Brain, gibt es auch sowas ganz Nettes in zweieinhalb Stunden, einen ganz guten Überblick über das Entity Framework, dann sieht man halt, dass die BIN in 10-15 Minuten ein komplettes Projekt gebaut haben, wo das Entity Framework drin implementiert ist.

[53:30] Das ist für den Einstieg auf jeden Fall gut und das ist für winzige Anwendungen bestimmt in Ordnung, da muss man vielleicht den Overhead nicht betreiben, aber sobald das Projekt ein bisschen anspruchsvoller wird und auch meine Klassen sich ein bisschen häufen, muss ich das Entity Framework genauso einsortieren, wie ich das auch mit anderen Klassen tue.

[53:48] Dass ich sage, ob ich jetzt ein Model-View-Controller-Modell habe, wo ich das auch in Schichten aufteile, muss ich auch genau hier sagen, ich gehe hin und sorge dafür, dass meine Models alle in einem Ordner sind und vielleicht beieinander liegen und nicht verteilt im Projekt und auf der anderen Seite muss ich natürlich dafür sorgen, dass auch projektweit nachher mein DB-Kontext verfügbar ist oder dass er vielleicht nur dort verfügbar ist, wo er wirklich gebraucht wird, wenn ich ein Sicherheitsproblem habe.

[54:18] Also das ist ziemlich diffizil, aber ich glaube, man kann es genauso sehen, wie mit jeder anderen Entwicklung, die man da betreibt, wo man sagt, ich habe ein Framework, das habe ich irgendwann mal implementiert und jetzt bin ich an dem Punkt, wo ich doch mal aufräumen muss in meinem Projekt und muss mich an irgendeine gewisse Architektur halten.

[54:36] Das ist so der Grundstock, ansonsten würde ich sagen, wenn halt das Projekt größer wird, kommt halt vielleicht nochmal das Projekt, ja nicht das Projekt, aber dass man hingeht und sagt, ich abstrahiere das, wie ich am Anfang gesagt habe, dass ich irgendeinen Data-Manager habe, der halt irgendwo über meinem DB-Kontext liegt und dass ich dann gewisse Sachen zusammenfasse, also wenn ich auf der einen Seite Flüge habe und auf der anderen Seite habe ich Passagiere von mir aus, dass ich sage, die haben beide irgendwo ihren Data-Manager und zum Schluss lege ich da noch meine Schicht drüber.

[55:06] Das ist dann davon abhängig, wie viel Zeit ich da investieren möchte und was das Projekt erfordert, weil wenn ich halt wirklich nur was Stupides aus der Datenbank abfrage und zurückschreibe, ist es vielleicht nicht nötig, aber wenn das komplexer wird, dann sollte ich mir darüber Gedanken machen.

[55:23] Eine generelle Lösung dafür würde ich sagen, gibt es nicht. Es gibt eine Menge Konferenzen, auf denen sich Leute damit schon beschäftigt haben und ich sage mal ihres Vorstellen und ich denke, wenn ich an den Punkt komme, wo ich mich um sowas kümmern muss, sollte ich da hingehen und mich informieren und mal gucken, wie haben es die anderen gemacht und es dann auf meine Problemdomäne abbilden.

[55:53] Wie sinnvoll findest du das? Zum Beispiel, haben wir noch gar nicht gesagt, aber so ein ORM nimmt einem ja auch die Abstraktion von der konkreten Datenbank ab. Das heißt, ich könnte im Java-Umfeld zum Beispiel einfach mal die Oracle gegen eine MySQL austauschen, wie man das ja auch ständig immer macht. Das ist ja ein so ein toller Vorteil, den man dadurch angeblich hat, aber wie wahrscheinlich ist es denn, dass ich jetzt sogar die Abstraktion der Datenbank, also das ORM, austausche?

[56:18] Also findest du das sinnvoll, dafür noch eine Abstraktion zu machen, dass man dann vielleicht anstatt Entity Framework doch ein Hibernate nimmt oder ist das vielleicht schon zu viel des Guten?

[56:26] Also ich glaube auch, dass man den ORM äußerst selten austauschen würde. Also wie du sagst, die Datenbank im Hintergrund, die würde man eher austauschen. Aber ja, das ist eine Frage, wie ich die komplette Architektur meines Projekts habe und ob ich vielleicht irgendetwas kapseln möchte. Ich glaube, es ist kein einfaches Thema und da eine pauschale Aussage zu geben, ist so meiner Meinung nach nicht möglich.

[56:51] Ich kenne halt einige, die halt nachher sagen, okay, ich habe da irgendwie ein Projekt, passt das strukturtechnisch, weil ich einzelne Projekte in meiner ganzen Projektmappe habe und ja, ich möchte das halt ein bisschen kapseln. Die gehen meistens auf so eine Lösung zu.

[57:10] Ich sehe das momentan ein bisschen skeptisch, weil ich das relativ selten brauche. Ich habe jetzt aktuell ein Projekt, wo ich mir genau um dieses Thema Gedanken mache, mich bis jetzt aber davor gescheut habe, das ein bisschen in die Tiefe zu verstehen, beziehungsweise mir Gedanken zu machen, wie ich das implementieren würde. Und das ist halt der Grund, warum ich weiß, ja, es gibt eine Menge Leute, die sich da drum Gedanken machen, die sich darum kümmern. Und ja, wie gesagt, eine pauschale Aussage würde ich mich jetzt nicht wagen.

[57:37] Also da kann ich es jetzt einmal mit Java vergleichen. Hatte ich schon gesagt, da gibt es diese Java-EE-Spezifikation für JPA und dagegen entwickle ich in meinem Java-EE-Code und ich kann dann tatsächlich einfach mal Hibernate durch, was auch immer, Eclipse Link, einen anderen Provider austauschen und das funktioniert einfach trotzdem. Also da hat sich, da macht sich jetzt tatsächlich vielleicht diese Spezifikationswut im Java-Umfeld bemerkbar, da programmiere ich einfach gegen eine von Java festgelegte Schnittstelle und der konkrete ORM-Provider, den kann ich testen.

[58:07] Also ob es sinnvoll ist oder nicht, ist jetzt mal völlig dahingestellt. Ich finde das auch nicht so sinnvoll. Ich werde das auch kaum austauschen, aber da geht es allein deswegen, weil halt so eine zentralische Stelle festgelegt ist. Sowas gibt es im Microsoft-Umfeld, glaube ich aber nicht. Oder gibt es da auch so eine Art Spezifikation, wie alle ORMs zu funktionieren haben?

[58:26] Also ich wüsste es nicht, weil ich glaube auch die Anzahl der ORMs, die im .NET-Umfeld so gebraucht werden, das beschränkt sich vielfach wirklich auf das Entity-Framework. Also ich habe jetzt wie gesagt ein Hibernate ausprobiert, was aber wie gesagt aus der Java-Welt kommt insofern, ja funktioniert alles ganz super und hat aus meinen Augen nur den Vorteil, wenn ich halt in .NET und in Java arbeiten muss, ist das für mich die Wahl, weil ich mich damit auskenne.

[58:53] Ansonsten sehe ich jetzt halt nicht so den richtigen Grund, das Entity-Framework zu verlassen. Falls da jemand eine andere Idee hat, was man nutzen könnte, bin ich natürlich gerne bereit, das mal auszuprobieren. Aber gefunden habe ich so nichts, was zumindest, ich sage mal, promotet wird. Es mag vielleicht irgendwelche Sachen geben.

[59:12] Und es gibt vor allem auch viele Erweiterungen für das Entity-Framework, die jetzt an der Stelle und viele architektonische Ideen, die Leute veröffentlicht haben, wo ich jetzt nicht wüsste, ob das dann mit jedem ORM auch funktionieren würde. Weil als Beispiel vielleicht fällt mir gerade noch ein, du hast ja eben gesagt, die Datenbank austauschen, man tauscht eine Oracle-Datenbank gegen eine andere. Im Microsoft-Umfeld ist ja eher, ich tausche eine Microsoft-SQL-Datenbank gegen eine Oracle-Datenbank.

[59:39] Und da sieht man dann, dass das funktioniert. Das kann man machen, das ist aber nicht ohne Aufwand zu betreiben. Weil das mit Oracle, es gibt eine Menge Erweiterungen dafür, die man kommerziell erwerben kann, die einem das Leben leichter machen.

[59:54] Und genau so ist das mit der Architektur auf der anderen Seite auch. Dass ich halt sage, ja, wenn ich es denn brauche, dann muss ich mich drum kümmern. Aber da bin ich auf jeden Fall noch in der glücklichen Position, dass ich das alles relativ einfach selber schreiben kann. Was wahrscheinlich daran liegt, dass es halt keine generelle Aussage oder ein bestimmtes…

[1:00:14] Naja, ich will jetzt nicht sagen pattern, aber sowas wäre mir auf jeden Fall nicht bekannt.

[1:00:22] Ja, also ich hatte das gerade auch so ein bisschen scherzhaft gesagt, also wir tauschen, glaube ich, nie irgendwelche Datenmarken einfach mal durch eine andere aus, weil die jetzt besonders viel besser ist oder so.

[1:00:30] Also ich würde zum Beispiel auch vermuten, wenn ich ein .NET-Shop bin, dass ich halt auch den SQL Server nutze, weil halt die Tools auch einfach perfekt darauf abgestimmt sind.

[1:00:37] Und so würde ich es im Java-Umfeld wahrscheinlich auch machen, würde ich halt eine Datenmark nehmen, in unserem Fall jetzt zum Beispiel Oracle.

[1:00:42] Also ich finde es einfach, das ist immer so schön, wie man es im Studium oder in der Ausbildung lernt, man macht das ja, damit man die Datenmark austauschen kann.

[1:00:49] Aber die Frage ist halt in der Praxis, wann macht man das denn wirklich?

[1:00:52] Also wenn man jetzt wirklich eine etablierte Anwendung hat, die seit 20 Jahren besteht, warum sollte ich da auf einmal die Datenmark austauschen?

[1:00:57] Außer wenn ich natürlich jetzt vielleicht von relational auf NoSQL oder weiß der Geier was wechseln will.

[1:01:01] Das ist natürlich was anderes, aber da hilft mir wahrscheinlich mein ORM auch nicht, weil das dann einfach nicht mehr funktioniert.

[1:01:05] Richtig und vor allem ist dann halt auch die Frage, ist es nicht einfach auf der anderen Seite Datenbank-Link zu verwenden?

[1:01:11] Ja, genau.

[1:01:13] Weil ich mich bei Oracle Apex benutze und sage, ich möchte jetzt meine Daten aus der SQL, Microsoft SQL Datenbank haben.

[1:01:19] Also ich eine Connection anlege und sage, du darfst einfach auch zurückschreiben auf die Microsoft Datenbank, dann ist es gut.

[1:01:25] Dann habe ich mir das Leben vereinfacht und die Datenbank im Prinzip auch ausgetauscht.

[1:01:30] Und ja, also es ist sehr projektspezifisch, bin ich der Meinung.

[1:01:34] Und das Thema, dass die Werbung dadurch kommt, ich kann die Datenbank austauschen, halte ich auch für obsolet.

[1:01:40] Ich bin auch der Meinung, der größte Vorteil ist einfach, dass ich meine Fehler eher finde und ein Framework bekomme, was getestet ist.

[1:01:48] Und ich die Unterstützung von meiner Entwicklungsumgebung habe, das ist einfach Gold wert.

[1:01:52] Und das ist gegen wenige Sachen nur aufzuwiegen.

[1:01:57] Also wie gesagt, die Performance ist eigentlich das einzige starke Argument, was man gegen ein ORM haben kann.

[1:02:03] Und das Thema Einarbeitung, ich weiß es nicht.

[1:02:06] Also ich glaube, es ist nicht so tragisch, sich damit mal drei Stunden zu beschäftigen und zu sagen, okay, jetzt habe ich zumindest mal eine Idee, wie es geht.

[1:02:12] Und jetzt fangen wir mal an und danach kaufen wir mal ein Buch und dann steigen wir das Thema tiefer ein.

[1:02:17] Das geht schon.

[1:02:19] Und ich sage mal, der Einstieg bereitet meiner Meinung nach weniger Kopfschmerzen als der Austausch einer Datenbank.

[1:02:24] Ja, definitiv.

[1:02:26] Aber das finde ich cool, dass du das Beispiel gerade gemacht hast, weil wir haben es tatsächlich bei uns in der Firma genau andersrum.

[1:02:31] Wir haben quasi ein Reporting auf SQL Server laufen und haben einfach eine Oracle-Datenbank als DB-Link dazu geschaltet, sodass wir jetzt einfach mit Microsoft Tools eine Oracle auswählen.

[1:02:39] Also genau so macht man es dann, weil das ist einfach viel zu viel Aufwand, einfach mal die Datenbank auszutauschen.

[1:02:44] Ja, vor allem im Normalfall auch zu riskant.

[1:02:47] Also wenn die Sachen von irgendeiner Produktion oder was Ähnlichem abhängen, dann habe ich nicht so viel Zeit, wenn das mal schief geht.

[1:02:54] Und dann fange ich an, ein Riesenprojekt draus zu machen.

[1:02:57] Dafür brauche ich Geld und so weiter.

[1:02:59] Da hängt ja mal so ein Rattenschwanz dran.

[1:03:01] Also da unterscheidet sich halt die Theorie von der Praxis.

[1:03:03] Und ich denke, ja, das Problem werden alle haben, dass sie sagen, ja, das sehe ich auch so.

[1:03:10] Ich kann das theoretisch tauschen, aber brauchen tue ich es nicht.

[1:03:13] Ja, genau.

[1:03:16] Ich habe jetzt noch durch deine Erzählung noch drei kleine Fragen aufgeschrieben.

[1:03:20] Und zwar, du meinst gerade, oder jetzt auch schon mehrfach, dass quasi das Objekt, mit dem ich eigentlich immer arbeite beim Entity Framework, das DB-Kontext ist.

[1:03:27] Ganz konkret im Code. Wie sieht das aus? Muss ich mir das selber erzeugen?

[1:03:30] Also mache ich irgendwo ein New-DB-Kontext und dann geht das los?

[1:03:33] Oder kriege ich das irgendwie injiziert? Oder wie funktioniert das ganz praktisch?

[1:03:36] Ich kann das ganz normal erstellen.

[1:03:38] Also ich sage mal, das erste Mal fange ich an, dass ich es mir new erstelle und sage, in meinem Using-Block übergebe ich direkt das Objekt und sage, dieses Objekt wird verwendet.

[1:03:46] Und der Using-Block sagt halt zum Schluss, dass über die Schnittstelle IDisposable das Objekt auch wieder zerstört wird.

[1:03:51] Und das ist halt eine ganz einfache Sache.

[1:03:54] Und wenn ich das halt in irgendeiner Form ablösen möchte durch irgendeine Abstraktionsschicht, dann kann ich das machen.

[1:04:00] Die Frage ist, ob ich das halt besser mache.

[1:04:02] Weil, wie gesagt, was einfacher ist als dieser Using-Block, wo ich einfach das Objekt reinschmeiße und sage, jetzt arbeite ich hier drin und zum Schluss ist das einfach tot und ich brauche mich nicht drum kümmern.

[1:04:13] Das ist halt meiner Meinung nach für jeden, der damit anfängt, eine ganz einfache Sache und ist einfach gut implementiert.

[1:04:22] Aber das ist nicht irgendwie, dass das Ding ein riesengroßer Singleton ist, der immer irgendwie mitläuft und ich kann einfach new, new, new machen und dann habe ich halt mal drei Kontexte.

[1:04:30] Ne, ist kein Singleton, nein.

[1:04:33] Also ist, wie gesagt, meiner Meinung nach auch unsinnig, wenn ich halt IDisposable implementiere, weil das bietet mir halt den Vorteil, dass es zum Schluss zerstört wird.

[1:04:42] Also ich brauche mich um nichts kümmern und ich habe auch den Vorteil, es bleibt nichts hängen.

[1:04:47] Ja, also von der Idee her ist das wahnsinnig gut.

[1:04:51] Und wie gesagt, jeder, der sagt so, ja, ich finde das keine gute Lösung, der kommt normalerweise von der Performance-Seite.

[1:04:57] Also die haben halt was gegen diesen Rapper im Rapper.

[1:05:01] Und ja, aber zum Arbeiten an sich ist das schon eine schöne Sache.

[1:05:06] Absolut. Also ich habe immer nur die ganze Zeit, wenn du das erzählst, im Hinterkopf, wie es halt in Java ist.

[1:05:10] Und da ist es halt so, dass dieser Entity-Manager, der so ziemlich diesem DB-Kontext entspricht, der muss halt über so eine supergeile Factory-Methode erzeugt werden.

[1:05:17] Und das ist halt dann alles immer ein bisschen aufwendiger.

[1:05:20] Deswegen wollte ich fragen, wie man es da macht.

[1:05:22] Also in Java wäre es dann einfach auch so, dass ich, wenn ich Java EE benutze, lasse ich mir diesen Entity-Manager einfach injizieren.

[1:05:28] Das heißt, ich habe ein Attribut inject und dann ist das Ding einfach da und ich darf das auch gar nicht newen, weil das dann quasi der Container für mich übernehmen würde.

[1:05:35] Deswegen, um das mal abzugleichen, wollte ich mal fragen, wie man das dann in .NET macht.

[1:05:38] Ja, wie gesagt. Using, Statement und ist die einfachste Variante.

[1:05:44] Wer möchte, kann da bestimmt mehr Aufwand betreiben.

[1:05:46] Also, ja, wie gesagt, ich kann, wenn ich den Rapper sozusagen einmal auspacke, mir fällt der Name leider nicht ein, wie der Rapper da drunter heißt.

[1:05:54] Der bietet wieder ein paar andere Möglichkeiten, ist dafür etwas performanter, wird aber, glaube ich, ab der nächsten Version gar nicht mehr unterstützt.

[1:06:03] Dann hat sich das Thema, glaube ich, eher erledigt.

[1:06:05] Und ja, also ich habe es bis jetzt noch nicht anders benutzen müssen.

[1:06:10] Wie gesagt, momentan überlege ich halt gerade, ob ich da irgendwo so einen Data-Manager drüber setze und das Ganze etwas abstrahiere.

[1:06:15] Bin ich mir aber selber noch nicht einig, wie ich das im Projekt unterbringe.

[1:06:18] Und ich denke, an der Stelle fängt es an, einfach projektspezifisch zu werden.

[1:06:23] Und das ist jetzt für den Anfänger, der damit anfängt, irgendwie nicht so relevant, glaube ich.

[1:06:30] Da ist wirklich, wie gesagt, das Entity-Framework einfach eine simple Sache.

[1:06:35] Eine Frage, die mir konkret immer noch unter den Nägeln brennt, ist, kann man das Ganze auch irgendwie schön testen?

[1:06:40] Also, wenn ich jetzt zum Beispiel irgendwo einen New-DB-Kontext im Code habe, dann bin ich ja quasi hart damit verdrahtet.

[1:06:45] In Java hätte ich jetzt den Vorteil, ich lasse mir das injizieren.

[1:06:48] Das heißt, ich kann in meinem Test einfach auch so einen Fake-Entity-Manager rein injizieren.

[1:06:52] Wie würde ich denn das im Entity-Framework dann machen?

[1:06:54] Ja, in meinem Unit-Test kann ich den DB-Kontext trotzdem nutzen.

[1:07:00] Und ich kann hingehen und kann im Prinzip die Datenbank im Speicher nachbilden.

[1:07:06] Das funktioniert.

[1:07:07] Und da gibt es Methoden, wie ich das testen kann.

[1:07:11] Und man findet auch relativ viele Beispiele.

[1:07:15] Das ist vielleicht auch übertrieben, aber wenn man weiß, wonach man suchen soll, findet man schon Beispiele, wie Leute das entsprechend implementiert haben.

[1:07:21] Wir haben es auch implementiert und das ist halt eines der Dinge, die ich halt immer wieder mitziehe.

[1:07:26] Also außer, dass ich im Prinzip ein paar Namen anpasse, nehme ich im Prinzip diesen Unit-Test, diese Grundstruktur einfach immer mit von Projekt zu Projekt.

[1:07:34] Und das ist ein, ich will jetzt nicht sagen ein Pattern, was ich jetzt geschrieben habe, aber ich sehe es als Pattern, was ich mitnehme in das nächste Projekt.

[1:07:42] Und damit ist die Testbarkeit schon gegeben.

[1:07:45] Die mag vielleicht, ich weiß nicht genau, wenn sie in Java, ob sie da besser gemacht ist und ob man damit mehr spielen kann, aber Unit-Tests sind auf jeden Fall nicht das Problem.

[1:07:56] Also man würde dann aber wirklich mit einer kleinen In-Memory-Datenbank echte Tests gegen eine echte Datenbank, die dann zwar nur im Speicher ist, aber immerhin durchführen.

[1:08:05] Richtig verstanden?

[1:08:06] Genau.

[1:08:07] Das heißt, das Einzige, was mir eigentlich fehlt, ist nachher der Kommit an die Datenbank, dass ich sage, jetzt meine Daten bitte persistieren.

[1:08:12] Das ist das Einzige, was fehlt.

[1:08:13] Ansonsten wird das Ding komplett so behandelt.

[1:08:15] Der Haken ist natürlich, ich muss ein paar Testdaten schreiben.

[1:08:18] Also wenn ich das halt in-Memory habe, kann ich halt nicht auf irgendwas zurückgreifen, was schon da ist.

[1:08:21] Und das muss ich natürlich auch wieder ans Projekt anpassen.

[1:08:23] Also manchmal habe ich, keine Ahnung, Hotelbuchungen und manchmal habe ich irgendwas anderes.

[1:08:28] Dann muss ich natürlich entsprechend meine Testdaten, dass ich da ein paar Zeilen in die Datenbank kriege.

[1:08:32] Aber das ist es wert.

[1:08:34] Also ich habe halt wirklich eine voll simulierte Datenbank und ich kann damit alle Testfälle abdecken.

[1:08:42] Ich halte es nicht für besonders trivial für jemand, der da vielleicht gerade einsteigt.

[1:08:47] Und man wird natürlich nachher faul, wenn man das natürlich nachher dreimal gemacht hat.

[1:08:51] Fängt man an wie ich und kopiert sich die Klassen einfach und sagt, ich nehme das mit.

[1:08:55] Ja, aber es geht auf jeden Fall.

[1:09:00] Und es gibt sogar ein paar Leute, die darüber bloggen und schreiben, wie sie es implementiert haben.

[1:09:05] Und ja, also die Ideen sich einfach mal anzugucken, ist die Zeit wert.

[1:09:11] Also das ist für mich so spannend, weil ich jetzt genau Anfang der Woche auf der Developer Week

[1:09:16] genau im Bereich Java darüber gesprochen habe, wie man das testen kann.

[1:09:19] Und da kann man jetzt auch verschiedene Sachen machen.

[1:09:21] Also dadurch, dass der Entity Manager einfach nur ein Interface ist, kann ich das in meinem Unitest wirklich einfach hart rausfaken

[1:09:26] oder stubben, je nachdem, was ich da testen will und habe wirklich gar keinen Bezug zur Datenbank.

[1:09:30] Aber wenn ich dann wirklich auch testen will, dass das Framework an sich sauber funktioniert,

[1:09:34] kann ich es halt auch so machen mit einer In-Memory-Datenbank zum Beispiel.

[1:09:37] In Java wäre das zum Beispiel Apache Derby.

[1:09:39] Die kann man mit drei Zeilen hoch und runter fahren.

[1:09:41] Dann muss man auch, genau wie du es gerade beschrieben hast, eigene Testdatensätze anlegen.

[1:09:45] Also das würde ich auch unbedingt empfehlen, dass man das Framework einfach mal komplett von vorn bis hinten testet

[1:09:50] und nicht einfach nur guckt, dass die richtigen Aufrufe stattfinden, sondern auch irgendwie mal nachweist,

[1:09:54] dass auch wirklich was in der Datenbank gelandet ist oder rausgelesen wird.

[1:09:57] Von daher, also das Vorgehen ist tatsächlich bei .NET und Java sehr, sehr ähnlich, wie ich jetzt gerade wieder feststelle,

[1:10:02] nur dass die konkrete Momentierung vielleicht leicht unterschiedlich ist.

[1:10:06] Ja, wie gesagt, es mag auch sein, dass es noch andere Möglichkeiten gibt.

[1:10:10] Aber für mich war es auf jeden Fall wichtig, dass ich halt zum Beispiel gucken kann,

[1:10:14] sind die Daten wirklich verändert worden in der Datenbank?

[1:10:17] Das möchte ich halt nachweisen.

[1:10:19] Und das ist für mich eigentlich der wichtigste Fall.

[1:10:22] Und deswegen ging für mich eigentlich kaum was um eine In-Memory-Datenbank rum.

[1:10:27] Ich halte es, es ist wahrscheinlich das mit dem meisten Aufwand, aber der Aufwand macht sich halt nachher bezahlt,

[1:10:34] weil ich halt während der Entwicklung feststelle, okay, vielleicht muss ich diese Spalte,

[1:10:40] muss ich einen anderen Datentyp bekommen oder der Datentyp muss erweitert werden.

[1:10:43] Und dann ist es halt wichtig, dass da irgendwo ein Testfehl schlägt und mir halt sagt,

[1:10:47] entweder du hast das noch nicht getestet oder das ist nicht komplett getestet.

[1:10:51] Ich erweitere die Spalte, weil ich merke, der Name muss länger als 10 Zeichen sein auf 15 Zeichen.

[1:10:56] Dass ich, ich sage mal, solche Sachen halt abtesten kann und dass ich auch gucken kann,

[1:11:01] ist der entsprechend in die Datenbank geschrieben worden? Kriege ich das zurück?

[1:11:06] Das sind meiner Meinung nach so die wichtigen Tests.

[1:11:10] Ja, absolut. Das kann ich nur bestätigen.

[1:11:12] Also es bringt mir nichts, wenn ich sauber sagen kann, dass zum Beispiel in Java jetzt der Entity Manager

[1:11:17] definitiv aufgerufen wurde, aber nachher funktioniert es trotzdem nicht und es landet nicht in der Datenbank.

[1:11:21] Also in dem Umfeld würde ich unbedingt auch dafür plädieren, echte Integrationstests,

[1:11:25] die auch mit einer Datenbank arbeiten, durchzuführen. Ja, unbedingt.

[1:11:27] Ja, und vor allem hast du halt den Vorteil, dass du dich im Service halt nicht mit einem Datenbankadministrator streitest

[1:11:31] und dir das Problem hin und her schiebst, sondern du siehst, dass das Problem bei dir liegt und das ist das Wichtige.

[1:11:35] Ja, genau.

[1:11:36] Ja, weil ich sage mal, es gibt ja noch genug Störfaktoren.

[1:11:39] Also ob das in der Firma dann nachher irgendein Subnetting ist, wo du dann feststellst,

[1:11:44] der Link funktioniert nicht so, wie ich mir das vorstelle oder weil jemand den Rechner genommen hat

[1:11:48] und ist an eine andere Netzwerkdose gegangen. Das sind dann halt so Kleinigkeiten.

[1:11:52] Kosten dich wahnsinnig viel Zeit und aus dem Grund kannst du dann halt sagen,

[1:11:54] okay, also der Test sagt, das funktioniert, also muss ich das Problem woanders suchen.

[1:11:58] So, was hast du gemacht? Ja, ich habe das Notebook umgesteckt. Aha.

[1:12:01] Ja, ja, genau.

[1:12:03] Kommt der Sache näher.

[1:12:05] Ja, sehr gut.

[1:12:06] Ich meine, sind wir mal ehrlich. Ich sage mal, wer hingeht und ich sage mal wirklich,

[1:12:10] dass alles testet, Unit-Tests schreibt und sich um solche Sachen kümmert,

[1:12:14] der kommt dann nachher relativ schnell auf solche Sachen.

[1:12:16] Wie lange hat man für sowas damals mal gesucht, als man das nicht gemacht hat?

[1:12:21] Also jeder von uns ist ja irgendwann mal auf den Trichter gekommen.

[1:12:24] So, jetzt habe ich drei Tage investiert, um festzustellen, dass derjenige das Notebook genommen hat

[1:12:27] und hat die andere Netzwerkdose genommen.

[1:12:29] So, und ich dann feststelle, die ist anders aufgelegt und ja, okay, ja, das ist jetzt doof.

[1:12:35] Ja, und dann stellst du fest, mit dem Unit-Test hätte ich das wahrscheinlich in 20 Minuten festgestellt.

[1:12:39] Das hätte ich also einmal laufen lassen, hätte mal dreimal drüber nachgedacht und festgestellt,

[1:12:42] das Notebook stand gestern am anderen Schreibtisch.

[1:12:45] So, und deswegen ist halt sowas wichtig und ich bin ein großer Freund davon,

[1:12:50] dass es halt eine In-Memory-Datenbank ist und ja, nichts abgespeckt ist

[1:12:55] und ich deswegen auch alles testen kann, was ich implementiere.

[1:12:58] Ja, finde ich sehr gut.

[1:13:01] Also auch wenn man Frameworks einsetzt, die einem das Leben einfacher machen, was ja völlig okay ist,

[1:13:05] um eigene Tests kommt man trotzdem nicht drum herum. Das finde ich wichtig.

[1:13:08] Nein, auf jeden Fall nicht. Das Thema ist halt, wenn man den ORM im Prinzip selber schreibt,

[1:13:12] dass man sagt, ich arbeite mit SQL und nachher baue ich mir die erste Abstraktionsebene da drum,

[1:13:17] dann habe ich den ORM nachgefasst.

[1:13:20] Dann kann ich mir die Arbeit sparen und die kann ich in Unit-Tests investieren.

[1:13:24] Das ist auch ein schönes Stichwort jetzt, weil ich das auch feststelle,

[1:13:28] wenn man gerade als Azubi vielleicht seine ersten Projekte gemacht und man hat in der Datenbank mal mit SQL gearbeitet,

[1:13:32] dann ist eines der ersten Projekte, ach, jetzt baue ich mir mal mein eigenes ORM,

[1:13:36] denn ich kann das ja viel besser als alle anderen.

[1:13:38] Und da kann ich nur jedem den Tipp geben, mach es nicht.

[1:13:41] Es gibt so viele Fallstricke, die man dabei berücksichtigen muss.

[1:13:44] Also wie du auch schon sagst, die Frameworks, die es gibt, die sind getestet,

[1:13:48] da sind professionelle Entwickler dahinter und das kann man als einzelner Entwickler nicht so nachbauen.

[1:13:53] Ja, ganz genau.

[1:13:56] Ja, eine letzte Frage, die mir noch eingefallen ist, also technisch,

[1:13:59] und zwar bin ich auch immer ein Freund davon, wenn man jetzt gerade auch diese modernen Ansätze,

[1:14:03] wie zum Beispiel Domain-Driven-Design und so verfolgt,

[1:14:06] da habe ich es immer ganz gerne, wenn so mein Domänenmodell,

[1:14:09] also die eigentlichen Klassen, die die Business-Logik darstellen,

[1:14:12] wenn die wirklich isoliert sind.

[1:14:14] Das heißt, wenn die keine Abhängigkeiten zu externen Frameworks,

[1:14:17] wie zum Beispiel so einem ORM haben.

[1:14:19] Und in Java ist es jetzt so, da habe ich jetzt so ein bisschen ein Trade-off,

[1:14:22] wenn ich meine Business-Klassen mit dem JPA persistieren möchte,

[1:14:26] dann habe ich halt mindestens mal diese komischen Annotationen an den Klassen

[1:14:30] und damit automatisch eine Abhängigkeit in das Framework rein.

[1:14:34] Ist es beim Entity-Framework so, dass das auch immer so ist,

[1:14:37] oder kann ich wirklich, ich sage mal, ein reines Domänenmodell schreiben,

[1:14:40] was keinerlei Abhängigkeiten hat,

[1:14:42] und das Entity-Framework geht einfach von draußen drauf und persistiert die dann?

[1:14:45] Ist das möglich?

[1:14:48] Ja, schwierig.

[1:14:50] Ja, wie mache ich es am besten?

[1:14:52] Also in dem Moment, wo ich natürlich ein Using-Statement irgendwo in meiner Business-Logik habe,

[1:14:56] die mir die Daten persistiert, habe ich eine Abhängigkeit.

[1:15:00] Wenn ich hingehe und das durch irgendeinen Data-Manager wieder abstrahiere,

[1:15:03] kann ich diese Abhängigkeit natürlich rauskriegen.

[1:15:06] Ja.

[1:15:09] Wie gesagt, Projektgröße meiner Meinung nach.

[1:15:12] Also ich kann mit sowas halt leben.

[1:15:14] Wenn es halt überschaubar ist und wenn das Projekt halt größer wird,

[1:15:17] dann muss ich mich halt darum kümmern, wie kann ich das abstrahieren.

[1:15:20] Weil da hole ich mir sonst nachher nur Probleme mit rein.

[1:15:24] Jetzt ist halt der Vorteil, solange ich das halt nicht gegen einen anderen ORM austausche,

[1:15:27] ist das auch nicht so tragisch, ja.

[1:15:29] Ich sage mal, dann leidet im Zweifelsfall an Stellen meine Testbarkeit ein bisschen drunter.

[1:15:34] Das mag jetzt noch sein, aber im Grunde genommen kann man damit leben, sage ich mal.

[1:15:42] Für mich ist das gerade halt ein Thema.

[1:15:44] Das mit dem Data-Access-Layer war für mich so ein Thema, wo ich sage,

[1:15:47] ich brauche es eigentlich nicht.

[1:15:49] Ich bin nie in die verzweifelte Lage gekommen, ja, jetzt muss es sein.

[1:15:53] Jetzt langsam stelle ich halt fest, okay, das Projekt nimmt oder Projekte nehmen halt eine gewisse Größe an,

[1:15:59] wo ich sage, jetzt fängt es an sinnvoll zu werden, weil das fängt ansonsten tierisch,

[1:16:03] also sonst werden halt Änderungen aufwendig.

[1:16:05] Auf der anderen Seite, wenn ich es halt nicht verwende, Microsoft ändert nur geringfügig was

[1:16:14] und Microsoft ist dafür bekannt, dass man halt auch das, was vor zehn Jahren noch aktuell war, immer noch geht.

[1:16:19] Also mich wundert es halt, dass sie im nächsten Framework halt wirklich den einen,

[1:16:22] nicht DB-Kontext, aber das Vorgängermodell Manager oder wie er hieß, ich weiß nicht mehr genau, rausnimmt.

[1:16:28] Das hätte ich ihm nicht zugetraut.

[1:16:32] Also ich hätte schon gedacht, dass ich das lässig updaten kann und das würde immer noch funktionieren dann,

[1:16:36] auch wenn es zehn Jahre alt ist, aber das tut es dann anscheinend nicht.

[1:16:39] Also auch die gehen mit der Zeit, ja, muss man von Projekt zu Projekt entscheiden.

[1:16:45] Aber das Thema Data Access Layer ist auf jeden Fall noch eins, womit man sich dann mal beschäftigen kann,

[1:16:49] was aber meiner Meinung nach nicht zum Grundlagen gehört.

[1:16:52] Also wenn ich meine ersten Projekte gemacht habe damit und stelle fest, das habe ich jetzt verstanden,

[1:16:58] dann kann ich mich um sowas kümmern.

[1:17:00] Die Annotationen ziehe ich definitiv nicht in den Code rein.

[1:17:03] Also ich habe halt lediglich mein Using Statement, um die Datenbank auszulesen oder zu schreiben.

[1:17:09] Und das ist eigentlich alles, was mich daran koppelt.

[1:17:13] Okay, na cool. Gut, ja, dann haben wir auf meiner Liste der Fragen alles durchgekaut.

[1:17:19] Haben wir jetzt noch im Bereich ORM irgendwas vergessen, was du noch gerne unterbringen willst

[1:17:23] oder was wir noch besprechen sollten?

[1:17:26] Vielleicht eine Literaturempfehlung dazu, aber ansonsten, weil auf der technischen Seite hätte ich da jetzt nichts mehr.

[1:17:33] Okay, ja, dann ist das ein guter Einstieg.

[1:17:35] Was kannst du denn so empfehlen, um das zu vertiefen vielleicht an Literatur?

[1:17:38] Was kann ich da empfehlen?

[1:17:40] Also ich sage mal, im .NET Umfeld gibt es sowieso für die meisten Sachen relativ viel.

[1:17:44] Also auch schon bei Microsoft ist die Dokumentation ja schon nicht ganz klein.

[1:17:48] Aber so meine Lieblingsquelle ist auf jeden Fall Dr. Holger Schwichtenberg.

[1:17:54] Das ist der .NET-Doktor, der auch schon mal bei Heise schreibt.

[1:17:57] Und ich finde ihn erstens sympathisch, wenn er redet.

[1:18:01] Also die Vorträge von ihm, finde ich, kann man sich immer gut anhören.

[1:18:04] Meiner Meinung nach kommt immer das Gefühl rum, als würde er das halt wirklich auch noch alles selber machen.

[1:18:09] Also der ist halt nicht so der klassische Redner wie der Professor, der da zwar theoretisch von weiß, aber der das praktisch nicht anwendet.

[1:18:15] Und da kann er halt deutlich mehr zu sagen.

[1:18:17] Und bei ihm auf der Seite unter dem .NET-Doktor und ansonsten zum Beispiel als Konferenz.

[1:18:23] Die Basta ist immer ein ganz guter Anlaufpunkt, glaube ich.

[1:18:26] Da gibt es ein paar ältere Sachen, die bei YouTube zum Beispiel zur Verfügung stehen.

[1:18:30] Und er hat auch ein riesengroßes Beispielprojekt.

[1:18:34] Das nennt sich WWWings, glaube ich, wenn ich das richtig im Kopf habe.

[1:18:38] Und dieses Beispiel taucht immer wieder auf.

[1:18:41] Das taucht in seinen Folien auf, das taucht in seinen Büchern auf.

[1:18:45] Da ist es echt, es ist ganz gut dargestellt und es ist mit verschiedenen Projekten gemacht.

[1:18:50] Also eine normale Anwendung, eine Konsolenanwendung und ich glaube eine ASP.NET-Anwendung.

[1:18:58] Da ist also für viele Leute was dabei.

[1:19:00] Da kann man immer ganz gut gucken und es gibt halt relativ viele Unterlagen über das, was er halt irgendwo auf einer Konferenz erzählt hat.

[1:19:07] Das ist auf jeden Fall die Anlaufstelle schlechthin.

[1:19:10] Ansonsten hat er noch das letzte Buch.

[1:19:12] Das habe ich auch gekauft und gelesen.

[1:19:15] Jetzt nicht, weil ich der Meinung bin, da werde ich extrem viel Neues lernen.

[1:19:18] Aber erstens frischt man halt wieder die Sachen auf, weil man halt wirklich nur in einem Teil immer arbeitet.

[1:19:24] Und auf der anderen Seite ist es halt auch mit 200 oder 300 Seiten überschaubar.

[1:19:30] Jetzt müsste ich mal gucken.

[1:19:31] Das ist moderne Datenzugriffslösung mit dem Entity Framework 6.

[1:19:34] Also aktuell oder noch aktuell, sagen wir mal so.

[1:19:38] Ja, ist jetzt auch nicht gerade teuer gewesen, glaube ich.

[1:19:41] War günstig und das gibt einen ganz guten Überblick, würde ich sagen.

[1:19:45] Und er spielt halt auch, glaube ich, wieder in dem Buch geht es, glaube ich, auch wieder um den Flugmanager.

[1:19:50] Also um seinen WW-Wings.

[1:19:52] So hat man halt den Vorteil, dass man viele Informationen um ein Projekt findet und auch das Projekt selber im Internet.

[1:19:59] Und das ist meiner Meinung nach ein guter Einstieg.

[1:20:02] Okay, cool.

[1:20:04] Ja, den Herrn Schwichtenberg, den sieht man auch öfter mal bei, genau wie du schon sagst, bei Heise und so.

[1:20:09] Der hat auch immer coole Artikel in der IX und CT und so. Kann ich empfehlen, ja.

[1:20:14] Ja, der schreibt auch noch für irgendein .NET Magazin.

[1:20:16] Ich weiß nicht, ob das .NET Pro ist oder irgendwie sowas.

[1:20:18] Da schreibt er auch schon mal für.

[1:20:20] Also der ist auf jeden Fall überall unterwegs und der veröffentlicht viel.

[1:20:25] Und mir ist er einfach auch sympathisch, weil wie gesagt, wenn man ihn auf einer Konferenz hört, das ist nicht so abgehackt, sondern aus dem Leben.

[1:20:34] Und er sagt dann immer, wir probieren das aus, ich zeig das mal gerade, ich kommentiere das mal im Code aus, ich mach mal dieses.

[1:20:39] Er hat dann auch schon mal, dass das nicht funktioniert, hat dann so zwei Gedenksekunden und sagt, ah ja, ich weiß, woran es liegt.

[1:20:45] Das ist ein bisschen auffällig, das jetzt zu ändern, wir machen das mal so und so.

[1:20:48] Also, das ist aus dem Leben. Und das finde ich einfach extrem sympathisch.

[1:20:52] Und das ist halt nicht so statisch, nur ich habe hier mal 20 Folien mitgebracht und daraus erkläre ich euch das jetzt.

[1:20:59] Sondern er macht dann auch Live-Vorführungen und eindeutig ein großes Plus.

[1:21:05] Okay, cool. Ja, wenn wir schon beim Thema Literatur sind, hast du noch irgendwie ein All-Time-Favorite-Buch,

[1:21:12] was du irgendwie jedem Softwareentwickler dringend ans Herz legst, weil das dein Leben verändert hat oder irgendwas?

[1:21:18] Oh, also damals, habe ich ja schon gesagt, im Studium hat es angefangen mit Clean Code.

[1:21:23] Und ja, das gehört auf jeden Fall zu meinen Lieblingsbüchern und ich muss immer schmunzeln, wenn du das mühlenartig vorstellst.

[1:21:32] Aber ich sehe es halt genauso.

[1:21:36] Ja, dann habe ich damals Objective-C and Cocoa gelesen. Das war auch ein Buch, das war der Einstieg in Objective-C für mich.

[1:21:48] Der ist auch immer hängen geblieben. Ich könnte jetzt zwar nicht mehr sagen, das Buch hat mich irgendwie inspiriert,

[1:21:54] aber ich fand es gut geschrieben damals. Ich habe mir auch schon vorgenommen, das wirst du irgendwann nochmal lesen,

[1:21:58] auch wenn du das, was drinsteht, so nicht mehr brauchst, weil du wahrscheinlich besser Swift lesen solltest.

[1:22:03] Aber ich finde es einfach, es hat mich damals einfach gefangen, das Buch.

[1:22:08] Und die beiden würde ich auf jeden Fall so dazu zählen, weil sie wahrscheinlich auch mich doch gelenkt haben.

[1:22:14] Und gerade das Thema Clean Code, das Buch kann man halt so lesen, weil ja, es stehen viele Informationen drin.

[1:22:20] Beim ersten Mal überfliegt man das, dann liest man es irgendwann noch ein zweites Mal und stellt halt fest, wie wichtig das Ganze ist.

[1:22:25] Und ja, also die beiden würde ich auf jeden Fall dazu zählen.

[1:22:30] Cool. Ja, perfekt. Kann ich auch nur unterstützen.

[1:22:33] Also jetzt Objective-C kann ich überhaupt nichts zu sagen, habe ich mich noch nie mit beschäftigt, aber das Clean Code auf jeden Fall.

[1:22:38] Was Aus- und Weiterbildung angeht, kann ich halt jedem nur raten, ich sag mal, Konferenzen, Bücher und natürlich, ich sag mal,

[1:22:48] sowas wie Pluralsight sind natürlich immer gute Sachen, weil man einfach irgendwo auf dem aktuellen Stand bleiben muss.

[1:22:53] Und das ist auch mit ORMs nicht anders gewesen, also das Entity Framework Core zum Beispiel wird schon eine ganze Zeit lang entwickelt,

[1:23:02] ist aber bei vielen noch gar nicht angekommen, dass es da was gibt.

[1:23:05] Und da gibt es zum Beispiel auch einen Pluralsight-Kurs, auf den man dann stoßen kann, wenn man das Ganze verfolgt,

[1:23:10] halte ich für doch eine wichtige Sache, ob es jetzt Pluralsight oder Udemy oder was weiß ich ist, ist egal.

[1:23:18] Ja, das muss schon irgendwo sein. Als Quelle, ja, immer eine gute Frage.

[1:23:24] Also für mich sind halt, man hat sich so mit der Zeit irgendwie ein paar Lieblingslinks zusammengesammelt.

[1:23:29] Für mich gehört auf jeden Fall der .NET-Doktor dazu, ich finde es immer ganz gut und es sind immer Themen, wo man dann sagt,

[1:23:35] ja, ich kriege jetzt hier einen Ansporn und dann muss ich mich selber darum kümmern, dass ich was finde.

[1:23:38] Ich glaube, das ist halt das Problem der Softwareentwickler, man muss sich halt selber darum kümmern.

[1:23:45] Und man muss halt auch gucken, dass man, wenn man später dann arbeitet und noch viel arbeitet, dass man das damit unterbringt.

[1:23:52] Und es ist halt noch nicht bei jedem Arbeitgeber angekommen, dass auch zum Arbeiten des Softwareentwicklers irgendwo gehört,

[1:23:59] dass man eine gewisse Zeit seiner Arbeitszeit darin investiert, sich weiterzubilden und gewisse Dinge einfach mal auszuprobieren.

[1:24:05] Zu sagen, ich habe mal gehört, das muss man, das ist jetzt gerade hip, da will ich mal einen Einblick haben

[1:24:10] und dann muss man einfach mal zwei Stunden oder drei Stunden investieren können, auch auf der Arbeit.

[1:24:14] Und ich glaube, das ist die hohe Kunst, das hinzukriegen, dass das halt nicht nur alles auf privater Seite läuft,

[1:24:20] sondern dass das eine gesunde Mischung ist.

[1:24:23] Ja, das kann ich nur unterstützen. Also jetzt rein zufällig hat meine Bachelor-Studentin gerade ihre Arbeit über Extreme Programming geschrieben

[1:24:31] und da gibt es ja in der neuen Auflage von, weiß ich nicht, sogar noch einen extra Punkt dafür, der heißt, glaube ich, sogar Slack.

[1:24:38] Und da sieht das XP vor, dass sich Entwickler also auch, genau wie du sagst, während der Arbeitszeit durchaus mit anderen Projekten beschäftigen dürfen.

[1:24:45] Zum einen natürlich auch im Unternehmen, um so ein bisschen so Wissensmonopole abzubauen,

[1:24:49] aber auch eben gerade, um halt auf dem Laufenden zu bleiben und handlungsfähig zu bleiben.

[1:24:52] Und das ist quasi in diese Entwicklungsmethodik schon eingebaut. Also das finde ich einen ganz wichtigen Punkt.

[1:24:58] Ja, ich würde sagen, wir haben es ja eben im Prinzip schon gesagt.

[1:25:01] Wie gesagt, du nutzt momentan den DB-Kontext und stellst bei deinem Projekt dann irgendwie nächstes Jahr oder über nächstes Jahr fest,

[1:25:08] so, jetzt gehe ich mal hin und aktualisiere mal die Version und stelle plötzlich fest,

[1:25:12] das, was ich vor dem DB-Kontext, also das, was der DB-Kontext rappt, ist immer, das habe ich vorher benutzt von mir aus,

[1:25:18] das gibt es jetzt plötzlich gar nicht mehr, was mache ich dann?

[1:25:21] Das sind halt Dinge, die sollte ich halt früh genug wissen und die muss ich halt mitkriegen und deswegen muss ich mich halt selber informieren.

[1:25:26] Und ja, ich sage mal, wie gesagt, das mit dem Codecutter morgens zum Beispiel, wie es die CCD-School zeigt und lebt, ist schwierig.

[1:25:36] Also wenn man, ich habe es eine ganze Zeit lang probiert, aber so wirklich konsequent durchsetzen ist eine harte Nummer,

[1:25:45] weil es gibt immer Sachen auf der Arbeit, hier kommt ein Termin, da hat jemand was Wichtiges und das ist immer wichtiger als das, was du machst.

[1:25:51] Das ist halt so. Und ja, ich weiß nicht, das ist auf jeden Fall schwierig.

[1:25:56] Ich probiere es, ich probiere die Studenten, die bei uns für ein Praktikum da sind oder eine Abschlussarbeit oder beides in Folge, dazu zu ermutigen.

[1:26:06] Im Normalfall, die wenigsten nehmen es an.

[1:26:10] Aber zumindest hat man sich mal mit der Nase darauf hingewiesen und gesagt, guck mal, da gibt es noch mehr.

[1:26:16] Und das ist, glaube ich, schon mal viel wert. Wenn sie es nachher umsetzen können im Job, umso besser.

[1:26:22] Ja, klasse. Finde ich gut. Ja, gerade im Nachwuchs muss man so ein bisschen manchmal auch zu seinem Glück zwingen.

[1:26:29] Finde ich gut. Bist du, habe ich noch gar nicht gefragt, eigentlich auch selber in der Ausbildung tätig?

[1:26:34] Also bist du irgendwie Ausbilder oder betreust da Studenten oder?

[1:26:37] Ja, bedingt. Also ich betreue schon Studenten. Wir haben ein paar Studenten, die mit uns entwickeln.

[1:26:42] Ja, aber ich würde mich jetzt nicht als Ausbilder bezeichnen.

[1:26:47] Also ich probiere ihnen was von dem mitzugeben, was ich weiß und was ich kann.

[1:26:52] Ob das jetzt im Sinne eines Ausbilders alles ist, weiß ich nicht.

[1:26:56] Ich habe es nicht gelernt, Leute auszubilden und wir haben keine Azubis in dem Sinne, sondern es sind halt normalerweise Studenten, die mit ihrem Studium fertig sind und eine Abschlussarbeit schreiben wollen.

[1:27:04] Im Zweifelsfall machen die vorher noch ein Praktikum und dann haben wir im Zweifelsfall zwölf Monate Zeit, im besten Fall sagen wir mal, mit ihnen zu arbeiten, weil halt die Einarbeitungszeit immer relativ lang ist.

[1:27:16] Das ist für uns schwierig. Also wer halt Praktikum und Abschlussarbeit schreiben will, der hat immer ganz gute Chancen, bei uns genommen zu werden, weil bis die zum Thema hingeführt worden sind und dann wirklich produktiv was tun können, womit man was anfangen kann.

[1:27:30] Also ob sie jetzt in der Abschlussarbeit, gerade die Masterstudenten, die halt wirklich was mit dem wissenschaftlichen Hintergrund machen müssen, da fängt es halt an aufwendig zu werden, dass wir auch einen Benefit dafür haben, den wir da reinstecken.

[1:27:42] Und man möchte ihnen natürlich auch irgendwas mitgeben. Also sie sollen ja gehen und sollen sagen, ja, hier habe ich was gelernt.

[1:27:49] Und ja, ich glaube, wir kriegen es hin, aber als Ausbilder im engeren Sinne würde ich mich nicht bezeichnen.

[1:27:58] Und dann passt ja vielleicht der Begriff Mentor ganz gut dazu.

[1:28:01] Ja, das könnte man vielleicht sagen. Ich habe mich jetzt noch nie damit beschäftigt, wie man das ganze Kind nennen sollte, sondern ich freue mich einfach, wenn jemand Interesse am Thema hat und sagt, ich will was lernen.

[1:28:09] Und zu manchen hast du wirklich guten Draht und die saugen das wie einen Schwamm auf und die gehen nachher raus und die haben einfach wahnsinnig was gelernt, weil die dann auch da plötzlich ein privates Interesse dran entwickeln.

[1:28:23] Und bei manchen ist es mir dann, habe ich dann nachher eher so ein weinendes Auge, dass ich sage, wäre der noch fünf Monate länger geblieben, dann hätten wir auch dieses Problem noch gelöst und hätten wir ihm da auch noch einen Schubs geben können.

[1:28:35] Und ja, wenn das aber dann nachher so ist und wenn ich sehe, dass die sagen so, jetzt mache ich noch dieses und jenes oder ich bewerbe mich jetzt in eine andere Richtung, weil ich jetzt festgestellt habe, das finde ich doch gut, dann denke ich mal, ist das nicht schlecht gelaufen, die letzten sechs bis zwölf Monate.

[1:28:52] Okay, super. Ich glaube, dann haben wir irgendwie einen runden Abschluss. Wenn die Leute jetzt noch ein bisschen mehr über dich erfahren wollen, vielleicht gibt es irgendwelche Anlaufstellen, hast du irgendwie Blog, Twitter, keine Ahnung was, wo man dich erreichen kann, wenn man möchte?

[1:29:04] Ja, also ich habe natürlich einen brachliegenden Blog, wie sich das so gehört und wie das auch schon, ich glaube, einer deiner Exerzosen bis zuletzt gesagt hat, sowas hätte ich auch. Aber prinzipiell kann man mich über eine E-Mail Adresse oder von mir aus Bexing erreichen, das geht auf jeden Fall gut.

[1:29:17] Die Sachen kann ich dir nachher schicken, dann kann man das mit in die Shownotes tun und dann kann sich jemand melden, wenn er möchte. Und ja, wir suchen natürlich immer Praktikanten bzw. Studenten, die ihre Praktikum- oder ihre Abschlussarbeit machen wollen und wirklich Interesse am Programmieren haben und sagen so, ich möchte in irgendeine Firma gehen, ich möchte ein Projekt machen, dann kann man natürlich gucken, ob wir da helfen können.

[1:29:42] Weil es ist für uns immer recht schwierig, die richtigen Leute zu kriegen, weil wir jetzt glaube ich nicht so der klassische Software-Arbeitgeber sind.

[1:29:51] Okay, also die ganzen Kontakte packen wir auf jeden Fall in die Shownotes und gerne, wenn du da vielleicht irgendwie eine Möglichkeit hast, wo man offiziell sowas anfragen kann als Praktikumsplatz oder sowas, packe ich das auch gerne mit rein, einfach mal rüber schicken.

[1:30:05] Man kann das Bewerbungsportal nutzen, da kann ich dir einen Link von schicken und im Zweifelsfall, wenn halt jemand im .NET-Umfeld arbeitet oder ja, wir machen auch noch ein paar andere Sachen, aber das, was ich zumindest betreue und was ich mache, ist eher .NET, dann kann man mir parallel noch eine E-Mail schreiben und ich kann im Zweifelsfall mal sagen, was brauchen wir, was suchen wir, weil die Projekte ändern sich natürlich immer.

[1:30:29] Unsere Studenten haben normalerweise recht viele Freiräume, also ich habe nichts dagegen, wenn die sich vier oder acht Wochen lang in ein Thema vertiefen und daran arbeiten und sagen, so und jetzt setze ich mich hin und fange an, das Ganze umzusetzen.

[1:30:41] Also da würde ich sagen, bieten wir schon ein paar Vorteile in unserer Abteilung, weil wir halt einfach wissen, dass es Zeit braucht, um das zu verstehen und eventuell das Projekt so umzusetzen.

[1:30:53] Super, ja, das ist doch ein guter Ansatz, dass man Leuten auch die Zeit gibt, um das dann zu vertiefen. Ja, perfekt, dann würde ich sagen, haben wir einen schönen Abschluss. Wenn du nichts mehr hast, was du noch dringend loswerden möchtest, dann sind wir fertig.

[1:31:06] Nee, konkret nichts.

[1:31:08] Okay, super, ja, dann sage ich ganz, ganz vielen Dank für dieses intensive Gespräch zum Thema ORMs. Hat mir sehr viel Spaß gemacht und war auch super viel spannender Inhalt dabei, wie ich finde. Also vielen Dank.

[1:31:17] Ja, ich habe zu danken für die Möglichkeit, das mal zu präsentieren und vor allem, dass dann auch mal was in Sachen .NET aus deinem Podcast rauskommt.

[1:31:26] Ja, das war dringend Zeit, dringend. Perfekt, ja gerne. Ja, vielleicht finden wir noch ein anderes Thema, wo wir uns nochmal unterhalten können. Hat mir wirklich viel Spaß gemacht.

[1:31:37] Dann sage ich vielen Dank und ja, alles Gute.

[1:31:40] Ja, Dankeschön, dir auch.

[1:31:47] Stefan, ich hoffe, es hat dir so gefallen wie mir. Es hat richtig Spaß gemacht. Du siehst es auch. Wir haben uns eigentlich richtig verquatscht zum Thema. Wir haben so viele Sachen rund um das Thema ORM behandelt. Also wirklich eine ganz tolle Geschichte.

[1:31:59] Und ja, ich würde mich freuen, wenn wir uns später nochmal unterhalten können zu anderen Themen, weil ich glaube, Stefan bringt noch einiges mit, was dich auch insbesondere hier vielleicht weiterbringen könnte. Mal schauen, wie sich das entwickelt.

[1:32:10] Ja, für die Shownotes, die wir schon angesprochen haben, schau doch einfach vorbei auf der Website unter anwendungsentwicklerpodcast.de slash 108 für die 108. Episode, die das hier heute war.

[1:32:21] Und weil wir schon ganz, ganz sicher die 30-Minuten-Marke gerissen haben heute, höre ich auch wie so oft mal auf zu plappern und sage vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss.

[1:32:39] Untertitel im Auftrag des ZDF für funk, 2017

Polyglot Clean Code Developer
About the Author
Ausbildungsleiter für Fachinformatiker:innen Anwendungsentwicklung, IHK-Prüfer und ehemaliger Hochschuldozent für Programmierung und Software-Engineering.

3 comments on “Stephan Görgens über Objektrelationale Mapper – Anwendungsentwickler-Podcast #108”

  1. Peter sagt:

    In über 15 Jahren Softwareentwicklung hatte ich ein Projekt tatsächlich mal, in dem die Datenbank getauscht wurde. Und zwar wurde dem Management die Lizenzkosten für Oracle zu teuer und es wurde entschieden auf PostgreSQL zu migrieren. Das war dann trotz JPA/Hibernate ein erheblicher Aufwand. Es gab in der Anwendung einige Stored Procedures und manche Datentypen machten Probleme und mussten speziell umgesetzt werden. Vor allem Binärdaten in Blobs. Die hat Oracle ganz anders behandelt als PostgreSQL und Hibernate hatte das nicht wirklich abstrahiert.

  2. Stefan Macke sagt:

    Autsch! Aber gut zu wissen, dass es in der Praxis auch wirklich mal relevant wird, eine Datenbank abzulösen. Der Treiber – die Kosten – ist natürlich auch nachvollziehbar! Oracle geht ganz schön ins Geld…

  3. Computerlinguist sagt:

    Wir haben ein Java-Projekt, das auf Oracle und Microsoft SQL laufen muss, weil verschiedene Kunden unterschiedliche Datenbanken verwenden.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert