Kategorie: Informatik

Exception Handling in Multi-Layered Systems

This is the first blog post here which is completely in English. And of course there is a reason for that. I currently don’t plan to do this regularly (maybe I should? I don’t know.). Anyway, here is the reason: Next week I’ll give a talk for the Australian Delphi User Group in Sydney. The talk will be a webcast, which means, I’ll stay here in Germany while the audience will be sitting on the other side of the globe. ADUG members who cannot be in Sydney can also attend using the web streaming system.

What am I talking about? If you are reading my blog, you should recognise the topic:

Title: Exception Handling in Multi-Layered Systems
Abstract (or maybe I should rather say “teaser” or something):
How do you structure software properly? Why should we think about the structure of a software? And how? How to handle exceptional cases? Is the Exception language feature always the best way? This talk has roughly two parts. In the first part we will have a look at architecture, layers and tiers. The second part deals with exceptions and how to use them properly. In the end we will see what the one has to do with the other.

Errata:

  • There is a typo on slide 17: it should read “defines” instead of “defined”.
  • Slide 22 is not translated (sorry for that). The note there means “Weak layering: Layer 3 may directly access Layer 1.”

This is basically the same talk I gave at the Delphi-Tage this year in Heidelberg. After my presentation in Heidelberg, Mathias Burbach, the president of the ADUG, approached me and asked if I could also give this talk in English. And so I do. The contents will be basically the same, although there are some minor changes.

Again there are slides and more elaborate talk notes:

Download: Exception Handling in Multi-Layered Systems (Slides) (Größe: 3.08 MB; bisher 97 mal heruntergeladen)
Download: Exception Handling in Multi-Layered Systems (talk notes) (Größe: 3.08 MB; bisher 171 mal heruntergeladen)

I haven’t had the time to translate everything, so the German talk notes are still more detailed (roughly eight pages more).

While translating, I also realised that by now I’m already more used to American English than the British one. In school I mainly learned the British version but in university I almost exclusively hear, talk, read and write AE. Wikipedia says Australian English is pretty much like BE, so I’ll try to get used to that variant again. Let’s see how good that works.

As always I’m highly interested in feedback of any kind. Tell me what you like but especially also what you didn’t like. I can only get better when I know where to improve. Don’t hesitate to mention even spelling mistakes or the like. I’m happy to hear about everything I can do better.

Update (24th November): Maybe I should share my impressions of the talk. I like giving talks and giving this one in English via a web stream was a quite interesting experience. The English talks I gave until now where about half an hour, so this one lasting 55 minutes (+discussion) was quite a bit longer. Nevertheless it proved to be not much of a difference. As far as I remember I haven’t been looking for words, etc. So I’m quite satisfied with the language although German is still a bit more comfortable for me.

Due to some technical problems, I had to interrupt my talk to wait for a part of the audience rejoining. This made me hurry up a bit to keep the time frame. I tried to do this in those parts of the talk the audience most likely was already familiar with. But I’m afraid I was a bit fast anyway.

Web streaming the talk in my eyes had two effects: a positive one and a negative one. The negative one is that I could not see the audience and thus could not react to whether they looked bored or confused or rejecting or whatever. Normally a good presenter should keep an eye on how the audience reacts. Here I didn’t have the opportunity to do so. The second effect I believe to have encountered was that not seeing the audience made me avoid saying “erm“. Normally I use this “erm” a lot (and I try to stop that). During the talk I found myself rather making an actual pause or speaking slower instead. This is good. My guess is that not seeing the audience makes me less feel the need to make this sound as it normally just works as a signal which says “Don’t interrupt me, I haven’t finished talking yet.” But maybe I also just have a wrong impression. I didn’t concentrate on this aspect as language was more important.

At the end there was the opportunity for discussion but there was only one question. Unfortunately in my eyes I didn’t answer this question well. It was actually pretty bad. So after the break I tried to give a better answer.

Like so often, feedback is scarce. It’s a pity. I’d love to hear some comments on my presentation style, my English, the topic, etc. Even negative comments. The above is just my impression and maybe it’s wrong. Most likely there are also aspects I don’t realise, so feedback is always good if you want to improve.

Fehlerbehandlung in mehrschichtigen Systemen

… oder kurz: Schichten und Exceptions

Die Delphi-Tage 2012 sind zu Ende. Wie üblich hab ich nen Vortrag gehalten. Diesmal gings um Schichten, um Exceptions und was das eine mit dem anderen zu tun hat.

Abstract:
Wie strukturiert man eigentlich Software? Braucht Software überhaupt eine Struktur? Und, wenn ja, wie kann die aussehen? Und wie behandelt man eigentlich Fehler und Ausnahmesituationen? Sind Exceptions hier das Maß aller Dinge? Wie setzt man sie richtig ein? Und was hat das Ganze mit Schichten zu tun? Dieser Vortrag gliedert sich in zwei Teile. Im ersten Teil wird gezeigt, wie man Software in Schichten strukturieren kann und welche Vorteile das hat. Außerdem werden ein paar Buzzwords wie “Architektur”, “Layers” und “n-Tier” geklärt. Der zweite Teil befasst sich mit Exceptions, wie man diese richtig einsetzt und was das Ganze mit Schichten zu tun hat.

Resümee:
Ich halte gerne Vorträge und noch lieber halte ich sie, wenn interessiertes Publikum vorhanden ist. Und das war es. Und es hat Spaß gemacht. Der Raum war voll und das obwohl die parallel stattfindenden Vorträge sich eigentlich auch sehr interessant angehört haben. Was mich besonders gefreut hat, war, dass es viele gute Fragen gab. Es ist immer schön zu sehen, wenn man mit dem Thema etwas getroffen hat, das nicht nur einen selbst interessiert.

Von meiner Seite aus muss ich sagen, dass eigentlich alles ziemlich gut geklappt hat. An Details kann man natürlich immer feilen. Deshalb mal wieder die Bitte um Feedback. Diverse positive Rückmeldungen hab ich schon bekommen (was mich sehr gefreut hat). Da ich mich aber nur verbessern kann, wenn ich weiß, was nicht so gut war, bitte ich auch und insbesondere um negatives Feedback. Was war nicht den Erwartungen entsprechend, was war verbesserungswürdig, unnötig oder unverständlich? Was hat gefehlt?

Folien und Vortragsnotizen:
Ich habe diesmal getrennte Folien und Vortragsnotizen. Auf den Folien steht nicht sonderlich viel drauf, was sie für den Vortrag passender gemacht hat (denke ich zumindest). Dafür gibts zusätzliche Vortragsnotizen. Diese sind demgegenüber ausführlicher und enthalten teilweise sogar ganze Textabsätze. Das ist jetzt nicht so detailliert und ausgefeilt wie ein Tutorial, aber es sollte ausreichen, um auch verständlich zu sein, ohne dass man den Vortrag gehört hat. Feedback hierzu ist natürlich auch willkommen. Also hier die Downloads:
Download: Schichten und Exceptions: Folien (Größe: 2.99 MB; bisher 149 mal heruntergeladen)
Download: Schichten und Exceptions: Vortragsnotizen (Größe: 3.05 MB; bisher 168 mal heruntergeladen)

Hinweise:

  • Danke für den Hinweis, dass in den Folien ein “Create” gefehlt hat. Ist jetzt korrigiert.
  • Nach dem Vortrag würde ich noch auf EurekaLog als Alternative zu madExcept hingewiesen. Der Hinweis findet sich nun auch in den Vortragsnotizen.
  • Ebenfalls vielen Dank für den Hinweis, dass man die UML-Packages, die erstmal ja nur eine logische Gruppierung darstellen, mit Delphi-Packages umsetzen kann. Der eigentlich passende Mechanismus wären IMHO wohl Namespaces, die es in Delphi in der Form nicht gibt. Und wenn man sich .NET und Java ansieht, wird man feststellen, dass es dort beides gibt: Namespaces/Java-Packages und Assemblies/jar-Dateien. Beides, logische und physische Gruppierung, ist orthogonal, d.h. vollkommen unabhängig voneinander. So kann eine Assembly mehrere Namespaces enthalten und umgekehrt. Dabei ist die physische Gruppierung die eindeutig schwergewichtigere. Trotzdem halte ich das für einen wertvollen Hinweis. Man sollte sich durchaus überlegen, ob Delphi-Packages nicht doch in Frage kommen, um einzelne Schichten/Packages voneinander zu entkoppeln. Ist wohl eindeutig eine Überlegung wert.
  • Die Graphik mit dem schlecht wartbaren Subsystem wurde mit einer Software des Fraunhofer IESE erstellt. Links dazu sind in den Vortragsnotizen.
  • Zwei “Problembereiche” von Exceptions wurden noch angesprochen: DLLs und Threads. Ich hab nochmal nachgeguckt, aber leider hab ich keine Links dazu parat. Und ein Patentrezept hab ich leider auch nicht. Von daher kann ich wohl nur wiederholen, was ich schon als Antwort gegeben hatte: Exceptions an DLL- und Threadgrenzen vermeiden (noch mehr als sonst) und ggf. auf die anderen Fehlerbehandlungsmechanismen ausweichen (Fehlercodes, OnError-Events, etc.). Man könnte sich auch andere Ausweichstrategien überlegen. Beispielsweise Records mit den Fehlermeldungen zurückgeben, Window-Messages verschicken, etc. Auch kann man sich um ne DLL auf der Aufruferseite wieder einen Wrapper schreiben, der Fehlercodes, die als Ausweichstrategie verwendet wurden, wieder in Exceptions umschreibt. Leider gibt es wohl keine perfekte Lösung. Was im konkreten Fall nun vorzuziehen ist, hängt dabei wohl auch stark von den jeweiligen Rahmenbedingungen und Anforderungen ab.
  • Testgetriebene Entwicklung/Test-First-Ansätze wurden erwähnt. Genau genommen unterscheide ich zwischen den beiden Begriffen (was nicht alle tun). Vielleicht mach ich dazu mal nen separaten Blog-Post darüber. Vereinfacht gesagt geht es darum, den Test-Code zuerst zu schreiben. Und das hat dann Auswirkungen auf das Design. Eigentlich geht es noch um viel mehr. Weil ich das aber hier nicht alles erwähnen kann, verweise ich lieber auf Wikipedia, die einschlägigen Blogs und diverse Bücher zum Thema.
  • Zu Assertions hab ich letztes Jahr schon ein bisschen was gesagt. Außerdem kann ich auf das auch anderweitig unbedingt zu empfehlende Buch “The Pragmatic Programmer” verweisen. Da gibts auch ein kleines bisschen etwas dazu. Im übrigen sind Andrew Hunt und David Thomas auch meiner Meinung, dass man Assertions nicht unbedingt deaktivieren muss.
  • Design by Contract wurde auch kurz erwähnt. Hier ein passender Link dazu.
  • Ich hoffe, ich hab hier nichts vergessen. Vielen Dank jedenfalls auch für die anderen Kommentare.

Nachtrag:
Eine Möglichkeit zur Verbesserung ist mir gerade selbst noch eingefallen: Mit einem Laserpointer würde sich wohl deutlich besser auf die Leinwand zeigen können als mit der Hand. Ich glaub, ich sollte mir für nächstes Jahr so ein Ding zulegen. Ansonsten würde ich gerne wissen, ob ich verständlich war. Sowohl inhaltlich alsauch sprachlich. War ich zu schnell, zu langsam, zu laut, zu leise? Wie war meine Körperhaltung und keine Ahnung was… Ich bitte auch um Kritik an Kleinkram.

Von Eiswaffeln und Tests

Tests scheint irgendwie niemand gerne zu machen. Warum auch immer. Das sehe ich gerade jetzt wieder. Ich betreue ja wieder mal das Softwareentwicklungsprojekt und da soll im Team eine Software entwickelt werden. Und selbstverständlich muss man die auch testen (das schreiben wir sogar vor). Hier aber mal eine kurze Statistik, wie das aussieht:

  • Innerhalb von ca. 2 Wochen haben von den 17 Gruppen gerade mal 5 überhaupt angefangen, Tests zu schreiben.
  • Davon benutzen gerade mal zwei Stubs.
  • Dafür hat eine Gruppe ganz offensichtlich schon Probleme, das Prinzip von JUnit zu verstehen
  • Und eine hat bisher nur ein paar Fingerübungen gemacht.

Wir kannten solche Probleme schon aus den letzten Jahren. Also hatten wir extra eine Saalübung zum Thema Testen gemacht. Wir hatten erklärt warum man testet, wie man das tut, wie und warum man Stubs verwendet und warum Test-First eine sinnvolle Strategie ist. Geholfen hat es offensichtlich wenig. :-(

Dabei könnten Unit-Tests helfen, Zeit zu sparen, weil man Bugs früher bemerkt. Ja genau: Richtig eingesetzt würden die Tests eigentlich Zeit sparen. Eigentlich…

Ich will jetzt aber wenigstens noch ein bisschen was zu Tests sagen. Nicht weil ich große Hoffnung hätte, dass das auf wundersame Weise 17-x SEP-Gruppen bekehrt (die meisten werden das hier wohl eh nicht lesen). Aber ich hab ein paar interessante Links, die vielleicht wenigstens *irgendwem* helfen könnten… weiter lesen »

Warum man Krypto nicht selbst machen sollte

Als ich so etwa in der 5. Klasse war, hab ich mal meine eigene Geheimschrift erfunden. Das hat mir damals unheimlich Spaß gemacht und ich kann sie sogar jetzt noch lesen und einigermaßen schreiben. Das ist ein Kinderspiel. Richtige Kryptographie ist aber alles andere als das. Immer wieder les ich von Leuten, die ihren eigenen Verschlüsselungsalgorithmus schreiben wollen — und das auch noch für eine gute Idee halten. Ich will jetzt mal versuchen, zu erklären, warum so etwas i.d.R. keine gute Idee ist. Ein paar aktuelle Begebenheiten im Security-Umfeld dienen dabei ein bisschen als Rahmenkulisse. weiter lesen »

Wie man Software entwirft

Wie schreibt man eigentlich Software?
– Nun, man tippt einfach den Code.
Und wie weiß man welchen Code man schreiben muss?
– Äh…

– Also, wenn man plangetrieben entwickelt, hat man ein Modell der Software, die man implementiert.
Und wie kommt man zu dem Modell?
– Man schreibt es auf, z.B. mit UML.
Und wie weiß man, was man aufschreiben muss?
– Äh…
– Also, wenn man agil entwickelt, entwickelt man i.d.R. testgetrieben, d.h. man schreibst zuerst Tests und aus den Tests kann man ersehen, welches Design man zu verwenden hat.
Und wie weiß man, wie man den Testcode schreibt?
– Man benutzt ein Unittest-Framework und testet damit die zukünftige Schnittstelle.
Und wie weiß man, wie die zu testende Schnittstelle aussehen muss?
– Äh…

OK, die Antwort auf diese Frage wird etwas länger. weiter lesen »

Continuous Integration

Letztens hab ich als kleine Seminararbeit in der Uni was über Continuous Integration geschrieben.

Hier meine Seminararbeit:
Download: Continuous Integration: Aspects in Automation and Configuration Management (Größe: 355.51 kB; bisher 250 mal heruntergeladen)

Und hier die zugehörige Präsentation:
Download: Continuous Integration (Präsentation) (Größe: 1.4 MB; bisher 209 mal heruntergeladen)

Wer sich für CI interessiertn sollte aber vielleicht eher den einschlägigen Artikel von Martin Fowler und/oder das Buch von Paul Duvall lesen.

Wenn das Quietscheentchen Probleme löst

Kann ein Quietscheentchen bei der Softwareentwicklung helfen? Kann es Probleme lösen, die man alleine nicht lösen konnte? Wäre eine ausgestopfte Ente besser geeignet?

OK, Spaß beiseite. Ob die Ente aus Gummi ist oder ausgestopft, spielt keine Rolle. Hauptsache sie ist tot. Wobei eine lebende Ente vielleicht auch…

Nein, ich hab keine Rauschmittel zu mir genommen. :mrgreen: Ich will damit tatsächlich etwas Ernsthaftes sagen: Manchmal ist es hilfreich, ein Problem einfach nur mal detailliert zu erklären; und auf einmal löst es sich wie von selbst.

Mir ist das des öfteren schon selbst passiert. Ich stand vor irgend nem Problem und mir wollte die Lösung partout nicht einfallen. Also hab ich mich entschlossen, die Frage anderen zu stellen und auf ne hilfreiche Antwort zu hoffen. Sowas tue ich gerne auch in Webforen. Und in solchen Webforen muss man sein Problem genau erläutern:

– Was ist der Kontext?
– Was ist das Problem?
– Was hab ich gemacht?
– Was hätte passieren sollen?
– Was ist stattdessen passiert?

Dazu noch ein paar schöne Zeilen Code oder ein Beispiel und dann weiß jeder was mein Problem ist. So werden die anderen User in die Lage versetzt, hilfreich zu antworten. Und manchmal versetzt man sich so auch selbst in die Lage, das Problem zu lösen. In so einem Fall ist es gar nicht mehr nötig, die Frage auch wirklich zu posten. Man hätte die Frage genauso gut ner ausgestopften Ente stellen können.

Oftmals sitze ich auch auf der anderen Seite. Ich lese Fragen und beantworte sie. Manchmal lese ich Fragen, bei denen sich der Fragensteller augenscheinlich keine große Mühe bei der Formulierung gegeben hat. Das ist nicht nur unhöflich (jemand erwartet eine kostenlose Antwort, die mitunter Mühe kostet, will sich aber selbst keine Mühe machen), sondern erschwert auch die Hilfe. Und auch das Quietscheentchen wird einem nicht weiter helfen, wenn man es nicht erst nimmt und das Problem nicht genau erläutert.

Dazu fällt mir noch ein Erlebnis aus meiner Schulzeit ein: Im Physikunterricht hatten wir den Druck in Flüssigkeiten durchgenommen. Ich hatte mir schon einige Zeit vorher vorgenommen, bei Gelegenheit ne Frage zu stellen: Druck hat man ja früher in “Millimeter-Quecksilbersäule” gemessen. Warum geht das? Müsste das nicht von der Bauart des Barometers abhängen?

Ich stellte also meine Frage. Der Lehrer wiederholte die Frage und auf einmal schoss mir die Antwort durch den Kopf. Ich konnte die Frage ja mit meinem eigenen Physikwissen beantworten! Des Rätsels Lösung ist das Hydrostatische Paradoxon, das wir schon kennen gelernt hatten. Ich hatte die Frage gestellt ohne selbst nochmal darüber nachzudenken. Kaum hatte ich die Frage gehört, war die Antwort sonnenklar. Hätte ich die Frage vorher ner Gummiente erzählt, wär mir ne kleine Peinlichkeit erspart geblieben.

Zu den Quietscheentchen:

(via)

Aaaalso, liebes Entchen, ich hab da mal ne Frage…

Joel on Software

Ich blogge hier jetzt schon seit mehr als zweieinhalb Jahren. Und manchmal scheint es tatsächlich Leute zu geben, die das lesen, was ich hier dank meiner Überheblichkeit so altklug von mir gebe. Ja, wirklich. Auf der anderen Seite gibts aber auch Blogs, die es viel mehr wert sind, gelesen zu werden. Ins Internet schreiben auch Leute, die wirklich Ahnung haben. Und einer dieser ist Joel Spolsky.

Ich hab ja schon mal sein Blog verlinkt, aber jetzt will ich doch noch mal etwas mehr dazu schreiben.

Joel Spolsky ist Software-Entwickler, ehemaliger Teig-Schieber in einer Großbäckerei, hat mal bei Microsoft gearbeitet und ist Mitgründer von StackOverfow. Und er kann wirklich interessantes Zeug schreiben. Wenn ich sein Blog lese, merke ich, wie langweilig und trocken meine Blog-Posts manchmal doch sind. Allein schon durch seinen Schreibstil kann ich einiges lernen, denke ich.

Aber was kann man da nun eigentlich lesen? Viel. Hier mal ein Ausschnitt dessen, was ich in letzter Zeit von ihm gelesen hab: weiter lesen »

Von unproduktivem Arbeiten, schlechtem Code, Astronauten und Klebeband

In diesem Blog-Post will ich mich darüber auslassen…

  • … warum unproduktives Arbeiten manchmal gut ist.
  • … warum schlechter Code manchmal gut ist.
  • … was Astronauten und Klebeband nicht gemeinsam haben.

weiter lesen »

Restklassenringe

Im ersten Semester lernt man im Informatikstudium Restklassenringe kennen. Diese bilden die mathematische Basis für diverse Kryptographie (beispielsweise RSA), aber auch anderes Zeug wie CRC. Gestern hatte ich im Forum mal ne oberflächliche Einführung in das Thema gegeben. Und damit das nicht verloren geht, will ich das hier nochmal posten. Wer also kein Informatik studiert, aber aus welchen Gründen auch immer wissen will, was modulare Arithmetik ist und wie man in Restklassenringen rechnet, hier eine knappe Einführung. weiter lesen »

powered by WordPress | QuickLaTeX | WordPress Themes