zum aktuellen Java Forum Stuttgart
•
Kontakt
•
Impressum
 |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
Abstracts und Vortragsfolien zum 8. Java Forum Stuttgart
Wer sich mit der Entwicklung von verteilten Unternehmens-Anwendungen beschäftigt, nimmt derzeit einen sich verstärkender Trend war: Ob bei EAI-, Workflow- oder sogar ERP-Spezialisten, überall ist eine Neu-Positionierung zur allumfassende Entwicklungsplattform für Geschäftsprozess-orientierte Lösungen in vollem Gange. Der Vortrag erläutert die gemeinsamen, zentralen Konzepte, die diesen oft sehr verschieden "getauften" Initiativen zugrunde liegen. Dabei werden insbesondere die Konsequenzen für die Software-Architekturen der so erstellten Lösungen von Morgen diskutiert. Denn daraus ergeben sich - oft noch ungenügend beachtete - Anforderungen an eigene Arbeitsergebnisse. Leider zeigt die Praxis, dass der selbst gesetzte Anspruch von Herstellerseite derzeit noch nicht in ausreichendem Maße erfüllt wird. Erfolgreich abgeschlossene Projekte zeigen aber: Der Mehrwert, der sich aus der Geschäftsprozess-orientierten Sicht auf die Aufgabenstellungen ergibt, ist heute bereits erreichbar - wenn auch noch nicht so, wie es uns die Marketingstrategen glauben machen wollen. Vortragsfolien: A1_Canotis.pdf
Die meisten Unternehmen haben heutzutage J2EE-Anwendungen im Einsatz. Manchen ist dieses noch nicht einmal bewusst. Leider kauft man sich mit der J2EE-Technologie neben den vielen Vorteilen auch den Nachteil einer kaum noch zu beherrschenden komplexen Technik ein. Die nahezu unendlichen Faktoren machen die Verfügbarkeit oftmals zum Glücksfall und gut funktionierende Anwendungen werden immer seltener. Application Performance Management unterstützt Betreiber, Support und Entwickler bei einer schnellen Lokalisierung und Behebung der auftretenden Probleme. Vortragsfolien: B1_Quest.pdf
his presentation is aimed at developers and architects who are currently developing Java applications, or have developed applications, and now want to optimize them for speed or throughput. Attendees will come away from this session with an understanding of why profiling techniques should be adopted and how to use today’s industry tools to aid in this methodology. Performance issues found in testing can be the result of numerous things. Lack of network bandwidth, hardware limitations, memory issues, and poor design are just a few of the examples encountered in development and testing. The way an application has been written may also be an issue. Before the other areas on the list are examined, examining your code at run-time will give you confidence that your code is not a factor. Understanding system resources that are consumed by an application without a tool in place can cause difficulties when examining symptoms - such as a slow response to the user, slow input/output, and whether the code is a factor. Customer requirements may include a performance factor, for example data returned from a Web site link in x ms. Historically, these problems have been raised at the end of a project and there is little time/budget remaining to fix these issues before some penalty is incurred. Using a profiling tool throughout development ensures any possible performance issues can be raised immediately, giving the project leader time to consider other options or inform the customer in plenty of time. Automated profiling tools have been available for some time and we’ll look at whether the cost of the tools justifies investing in these products and just how quickly they can benefit the developer. We’ll look at how to profile larger J2EE applications and servlets, refactoring and reprofiling without the annoyance of having to restart the application or even the application server. Attendees will learn how they can monitor the activities of different application servers, performing various processes such as loading servlets and deploying EJBs. For those developing multi-threaded applications, we’ll review the methods that can be employed to discover the causes of deadlocks in seconds rather than hours. Attendees will also learn how thread activity can be monitored to analyze race conditions and optimize the number of threads created. Vortragsfolien: C1_Enerjy.pdf
Diese Session führt aus Manager-Sicht in das Thema Open Source ein. Was ist Open Source eigentlich und wie funktionieren die Projekte und Communities? Was ist eigentlich die Apache Software Foundation und wer hat dort etwas zu sagen? Wie kann man als kommerzielles Unternehmen von Open Source profitieren und welche Business-Modelle kann man verfolgen? Insbesondere möchte dieser Vortrag aber auch aufzeigen, welche Fehler man als kommerzielles Unternehmen machen kann und wie man diese verhindert. Vortragsfolien: D1_s&n.pdf
Eclipse ist nicht nur die beliebteste Java-Entwicklungsumgebung. Mit der Version 3 wurde die Architektur von Eclipse auf die Rich Client Platform (RCP) umgestellt, die auch als Basis für beliebige Desktop-Anwendungen genutzt werden kann. Die RCP ist nichts anderes als eine durch ein großes Refactoring von Eclipse 2 entstandene Platform, die allgemein verwendbare Teile wie die Plug-in Laufzeitumgebung und das UI-Framework (SWT, JFace, Workbench) enthält. Wir geben einen Überblick über die Architektur und die Möglichkeiten der RCP und zeigen, wie sich Business-Anwendungen auf Basis der Rich Client Platform implementieren lassen. Vortragsfolien: E1_Lippert_Gerhardt.pdf
Immer öfter wird heutzutage in Software-Projekten eine integrierte Plattform für die Software-Entwicklung, Requirements Management, Change Management und Configuration Management gefordert. Dabei sollen Redundanzen vermieden werden und ein gemeinsames Repository zu Grunde liegen. Nur so kann der Integrationsaufwand verschiedener Werkzeuge so gering wie möglich gehalten. Aufgrund der Komplexität vieler Projekte ist es heute zwingend erforderlich, einen Nachweis für jede Änderung am Code und am Dokument zu haben und diese bis zur ursprünglichen Anforderung zurückverfolgen zu können. Dabei soll die Arbeit des Entwicklers nicht darin liegen die Verknüpfungen zwischen Requirements und Sourcecode-Änderungen zu pflegen. Die erfolgt über die Zuordnung zu Arbeitscontainern, genannt Change Packages. Hier werden Änderungen am Code, z.B. checkin, checkout, rename, move, delete, hinterlegt, die von einem Entwickler zur Erledigung der zugeteilten Aufgabe durchgeführt wurden. Die MKS Integrity Suite 2005 verknüpft die oben genanten Anforderungen und greift dafür auf nur eine einzige Datenbasis zu. Dadurch werden über den gesamten Produktlebenszyklus hinweg Fehler minimiert und somit die Qualität der Projekte maximiert. Der Vortrag zeigt diesen Ansatz anhand der Integration von Eclipse 3.x mit der MKS Integrity Suite2005. Gezeigt werden eine Folienpräsentation sowie eine Life-Demo. Vortragsfolien: A2_MKS.pdf
Die Komplexität von J2EE hat sich der von Corba angeglichen. Dies wird oft als Nachteil im Vergleich zu .Net aufgeführt. Apache Beehive vereinfacht die Entwicklung von J2EE Applikationen drastisch. Hierzu wird eine deklarative Programmiermethodik benutzt, die mit Meta tags den Entwickler von stereotypen Tätigkeiten befreit. Dies führt zu weniger Code bei weniger Fehlern und kürzerer Projektlaufzeit. Dieser Vortrag beginnt mit einer Einführung in den Metadaten-Standard JSR 175, die Basis für den JSR 181(Web Services Metadata). Anschließend werden die einzelnen Bausteine von Apache Beehive erläutert:
Vortragsfolien: B2_BEA.pdf
This presentation focuses on Visual Numerics' implementation of Neural Network technology. It goes into technical detail about the algorithms and Neural Network techniques. The Visual Numerics collection of neural network and data pre- and post-processing algorithms, written in 100% Java, provide a highly configurable neural network algorithm approach, and facilitate for smooth system integration. Vortragsfolien: C2_Visual-Numerics.pdf
In diesem Vortrag wird diskutiert, welche typischen Szenarien es für Makros gibt und wann es sinnvoll ist, den Code vollständig getrennt vom Dokument zu halten. Weiterführend werden die Vorzüge von Java als "Makro"-Sprache skizziert, mit Rückgriff auf die Features der Eclipse-IDE. An einem Beispiel wird gezeigt, wie man mit Eclipse Java-Makros für OpenOffice-Dokumente erzeugt und assoziiert. Dabei werden die mitgelieferten Tools von OpenOffice benutzt. Über ein PlugIn für Eclipse wird danach gezeigt, wie man die Zeiten zwischen Entwicklung/Deployment/Testing/Bugfixing drastisch senken kann und wie Java-Makros über den Eclipse-Debugger untersucht werden können. Folgende Aspekte werden im Rahmen des Vortrages beschrieben:
Ausführbare Source-Code-Beispiele als Live-Demo während des Vortrags dienen zum besseren Verständnis. Vortragsfolien: D2_riess.pdf
Java-Programme stehen immer wieder im Ruf langsam zu sein. Die graphische Standardoberfläche "Swing" hat in der Vergangenheit zu diesem Ruf beigetragen, da sie nur wenige Plattform-Steuerelemente nutzt und alles selbst zeichnet, um auf allen Plattformen gleich auszusehen. Dies führt sowohl zu einem erhöhten Ressourcenverbrauch als auch zu einem Look & Feel, das den Originalplattformen oft nicht genau entspricht. Mit dem Standard Windowing Toolkit (SWT), das im Rahmen des Eclipse-Projektes entstanden ist, gibt es nun eine Alternative, die für verschiedene Plattformen zur Verfügung steht, auf den nativen Elementen der jeweiligen Plattform aufbaut und effizienter als Swing ist. JFace bietet fortgeschrittene Konzepte für Viewer, die auf SWT aufbauen. Dieser Vortrag bietet eine Einführung in SWT. Es werden die Design-Grundlagen behandelt und anhand praktischer Beispiele der Einsatz von SWT und JFace in Projekten gezeigt. Dabei wird immer wieder auch ein Vergleich mit Swing angestellt. Außerdem wird gezeigt, wie man SWT um neue Steuerelemente erweitern kann. Dieser Vortrag wendet sich an Entwickler und Manager, die vor der Entscheidung stehen, Swing oder SWT in einem neuen Projekt einzusetzen. Dabei wird auch auf die Möglichkeiten der Eclipse Rich Client Platform eingegangen. Vortragsfolien: E2_Cortex-Brainware.pdf
Prozessportaltechnologie, wie die abaXX.components, ermöglicht sehr effiziente Umsetzungen von Geschäftsprozessen. Um das zu demonstrieren wird in diesen Vortrag ein vollständiger Geschäftsprozess innerhalb von 45 Minuten live umgesetzt. Dabei werden alle Aspekte der Umsetzung gezeigt: Die Modellierung des Prozesses auf Geschäftsprozess- und technischer Ebene, die Definition und Umsetzung der beteiligten Business Objekte und Aktivitäten, die Erstellung der Dialogelemente als Portlets sowie die Bereitstellung der erzeugten Prozessanwendung in einem Portalrahmen. Die Vortragsfolien liegen uns leider noch nicht vor.
Anfang 2004 hat Sun die Final Version der JavaServer Faces Spezifikation veröffentlicht. Es ist eine Spezifikation, auf den die Java-Gemeinde lange gewartet hat. Mit Hilfe des UI-Frameworks sollen Anwendungsentwickler besser und vor allem auch schneller moderne und leistungsfähige User Interfaces für Webanwendungen entwickeln können. Nach dem ersten Hype um diese neue Technologie ist JSF mittlerweile in einer Phase, in der es gilt, sich auch als Standard in der Industrie zu etablieren. Dies funktioniert jedoch nur, wenn eine breite Toolunterstützung von den namhaften Herstellern gegeben ist und die Integration in bewährte IDEs möglich ist. Der Vortrag soll zunächst einen Überblick über die Technologie und die Funktionsweise von JavaServer Faces geben. Ein Schwerpunkt soll aber auch auf die Einsatzmöglichkeiten in Projekten gelegt werden: Welche Tools stehen einem Entwickler bereits heute zur Verfügung, wie praxistauglich ist die Referenzimplementierung und was bringen künftige Releases der Spezifikation. Es soll gezeigt werden, wo sich JavaServer Faces technologisch heute befindet und was künftig von dieser Spezifikation erwartet werden kann. Vortragsfolien: B3_Bosch.pdf
Das langersehnte Java 5.0 ist seit Herbst 2004 nun endlich erhältlich. Die neue Version lockt mit zahlreichen Erleichterungen für den Programmierer. Doch einige der neu eingeführten Funktionalitäten bringen gewisse Tücken mit sich oder verhalten sich anders gegenüber der Erwartung. Der Vortrag versucht, bewußt den Finger in die Wunde zweier neuer Errungenschaften von Java 5.0 zu legen: Autoboxing und die statischen Imports. Gezeigt werden sowohl die Motivation, die Funktionalitäten überhaupt in der Sprache zu verankern, ihre Funktionsweise, aber auch ihre kleinen Nachteile, vor allem im Hinblick auf das objektorientierte Paradigma. Vortragsfolien: C3_aformatik.pdf
Für Java Entwickler wird die häufig vorhandene Komplexität von Web Anwendungen als normal empfunden. Ein Grund für diese Komlexität sind technisch weit überdimensionierte Frameworks (z.B. EJB), die Anforderungen adressieren, die nur von einem sehr kleinen Teil von Web Anwendungen tatsächlich benötigt werden. Ein weiterer Grund für die Komplexität sind die häufig extrem langen Compile- und Deployzyklen im J2EE-Umfeld. Dynamisch typisierte Skriptsprachen, wie PHP ermöglichen in der Regel eine effizientere Entwicklung, gelten u.a. bzgl. des Designs aber als unsauber. Eine Alternative bietet das Web Framework Ruby on Rails (www.rubyonrails.org) für die objektorientierte Skriptsprache Ruby. Rails basiert auf einer sauberen MVC Architektur, ermöglicht die testgetriebene Entwicklung, und kommt im Vergleich zu Java ohne umfangreiche Konfigurationen und mit deutlich weniger Code aus. Da die Anwendung nicht compiliert und deployt werden muss, ist ein unmittelbares Feedback während der Entwicklung gegeben. Der Vortrag stellt Ruby on Rails vor und vergleicht die Arbeit mit der Web Entwicklung in Java (am Beispiel Struts). Es wird aufgezeigt, welche Konzepte erst durch Ruby möglich werden und wo Java Vorteile bietet. Rails wird nicht als eine Ablösung für Java Web Frameworks vorgestellt. Vielmehr wird eine Alternative für Projekte präsentiert, für die PHP nicht gewünscht ist und Java Web Frameworks mehr Komplexität erzeugen als nötig. Für Java Entwickler bietet der Vortrag die Möglichkeit, von einer anderen Sprache und Technologie zu lernen. Auch, um die eigene Arbeit mit Java und Java Web Frameworks zu reflektieren und gegebenenfalls zu verbessern. Vortragsfolien: D3_Baustert_Wirdemann.pdf
JSR-208 (JBI) definiert eine Standard-basierte Integrationsplattform und stellt damit einen wichtigen Baustein im Umfeld Service Orientierter Architekturen (SOA) dar. Im Vortrag werden daher zuerst traditionelle EAI und SOA gegenübergestellt und dabei erläutert, welche Rolle JBI in diesem Kontext spielt. Neben der Gesamtarchitektur von JBI werden die einzelnen Komponenten und Schnittstellen eines JBI-Containers detailliert vorgestellt. Entwicklern, die JBI in eigenen Projekten einsetzen wollen, wird an Code-Beispielen gezeigt, wie sie selbst Service-Engines oder Binding-Komponenten erstellen können, die in einem JBI-Container arbeiten. Eine kurze abschließende Demonstration verdeutlicht neben Installation, Deployment und Konfiguration von Service-Engines und Binding-Komponenten, auch die Administration und den Betrieb einer JBI-Umgebung. Vortragsfolien: E3_Sun.pdf
Ein gutes Software-Projekt beginnt mit einer Spezifikation und wird maßgeblich durch deren Qualität beeinflusst. Es gilt das Motto "Sage mir wie dein Projekt beginnt, und ich sage Dir, wie es endet." Auf dem Markt sind umfangreiche Werkzeug-Suiten für die Erstellung von Spezifikationen erhältlich, welche für die meisten Einsatzgebiete jedoch zu schwergewichtig sind. Häufig findet stattdessen in vielen Unternehmen für das Requirements Engineering ein Template-basierter Word-, Excel- oder HTML-Ansatz Verwendung. Dieser Vortrag stellt einen Ansatz vor, der auf Eclipse-Basis die strukturierte und komfortable Erfassung von Anforderungen auf der Grundlage von Modellen erlaubt. Die einfache Definition neuer Ergebnistypen, sowie deren Struktur und Abhängigkeiten ermöglichen den Einsatz des Werkzeugs in nahezu jedem Unternehmensumfeld. Der leichtgewichtige Ansatz ermöglicht konsequentes Tracing sowie bereits während der Phase der Anforderungsermittlung zuverlässiges Projektcontrolling. Weitere Vorteile dieses Ansatzes sind die eng integrierte Weiterverwendung der entstandenen Dokumente in den nachfolgenden Implementierungsphasen, sowie die permanente Sichtbarkeit der Abhängigkeiten zwischen Implementierung und Spezifikation. Zum Ende des Vortrags wird die Implementierung des Ansatzes in prototypischer Werkzeugform gezeigt. Vortragsfolien: A4_GEBIT.pdf
Über 70% aller Angriffe erfolgen heute über Schwachstellen im Anwendungsdesign oder der Implementierung, nicht über Netzwerke. Somit sind "Application Attacks" die größte Gefahr für Ebusiness, da sie zudem von Firewalls, SSL und anderen herkömmlichen Technologien nicht abblockiert werden können. Nur das richtige Design und eine korrekte Implementierung einer Anwendung kann schützen. Dieser Vortrag spricht Entwickler und Manager an, die Ihre Enterprise Anwendungen gegen interne und externe Hacker schützen wollen. Er gibt einen Überblick auf die vielfältigen Aspekte der Sicherheit in J2EE Web-Applikationen und wie sie zuverlässig zu schützen sind. Teilnehmer lernen verschiedene Angriffsstrategien und Verteidigungen für JSP, Servlets und EJBs kennen. Der Vortrag wird praxisnah und mit vielen Beispielen gestaltet. Eine "Live Hacking" Demonstration zeigt, wie eine laufende J2EE Applikation mittels SQL-Injection, Cross-Site Scripting, Missbrauch des Invoker-Servlets, unsicherer Kryptographie, Konfiguration des Containers u.v.m. attackiert werden kann. Durch die Live Demonstration erhält das Seminar eine direkte Aktualität, die das Thema den Teilnehmern in einer klaren, sehr deutlichen Form aufzeigt. Der Vortrag basiert auf konkreten Erfahrungen und Beispielen aus der Praxis: es wird keine graue Theorie vermittelt. Vortragsfolien: B4_OPTIMAbit.pdf
Mit Java 5.0 stehen eine Menge Neuerungen und Veränderungen zur Verfügung. Eine besonders interessante Neuerung sind die Annotations, mittels derer man Klassen, Methoden etc. Metainformationen mitgeben kann. Neben einem Set von vordefinierten Annotationen kann man auch eigene definieren. Dieser Vortrag beschäftigt sich mit den Möglichkeiten der Annotations, wie man Code-Teile nach Belieben attributiert und diese Daten statisch oder dynamisch auswertet. Der Vortrag richtet sich an Software-Architekten, Entwickler und Projektleiter, die sich über die Möglichkeiten, die Java Annotations bieten, informieren möchten. Neben einem umfassenden Überblick bietet der Vortrag auch einige praktische Beispiele für die effektive Verwendung der Annotations. Vortragsfolien: C4_MATHEMA.pdf
Model Driven Architecture (MDA) der OMG ist der Standard für modellgetriebene Softwareentwicklung. Die Nutzung eines plattformunabhängigen Modells vergrößert den Modellierungsanteil bei der Softwareentwicklung und ermöglicht im Vergleich zu herkömmlicher Code-Generierung eine weitergehende Abstraktion vom tatsächlichen Zielsystem. MDA geht selbstverständlich auch an der Open-Source-Bewegung nicht spurlos vorüber. Es existieren inzwischen eine Reihe Open-Source-Projekte, die den MDA-Ansatz aufgreifen und entsprechende Entwicklungswerkzeuge realisiert haben. Dieser Beitrag stell eine Reihe dieser Open-Source Werkzeugen für die Entwicklung mittels MDA vor und bewertet diese bezüglich Konformität zur MDA, deren Einsatzreife sowie deren Features und Einschränkungen. Zu den untersuchten Werkzeugen gehören JAG, Jamda, FUUT-je, OpenMDX, UMT sowie AndroMDA. Anhand dieser Bewertung erfolgt eine Werkzeugauswahl und ein Erfahrungsbericht mit dem aus unserer Sicht zur Zeit am weitesten entwickelten Open-Source MDA-Werkzeug. Vortragsfolien: D4_Wanner.pdf
Der Java-Compiler und auch die populären IDEs bieten bereits einige Checks und Komfort bei der Erkennung und Vermeidung von Fehlern bzw. bei der Einhaltung von Kodierrichtlinien. Leider kommt es in der Praxis dann doch wieder zu Laufzeitfehlern. Genauso werden zu leicht Kodierrichtlinien mißachten, was anderen Entwicklern am selben Projekt die Arbeit erschwert. Dieser Vortrag möchte einige Tools anhand ihrers Eclipse-Plugins vorstellen, die hier zusätzliche Checks durchführen und verdächtigen Quellcode markieren. Checkstyle und PMD kümmern sich dabei mehr um das "Aussehen" und die Einhaltung einiger Programmierregeln. Findbugs analysiert den generierten Bytecode und ist damit auch in der Lage, potenzielle Laufzeitfehler zu finden. In einem größeren Projekt, bei dem bereits lauffähiger Code vorlag, konnten durch den Einsatz von Findbugs initial über 100 potenzielle NPEs ausgemerzt werden. Vortragsfolien: E4_syngenio.pdf
Anfang des Jahres konnte die Programmiersprache Java ihr 10-jähriges Bestehen feiern. Damit kann man die damit verbundenen Technologien und Werkzeuge durchaus als bewährt in Theorie und Praxis bezeichnen. Viele große Anwendungen haben die Feuertaufen bestanden und leisten Tag für Tag solide Dienste. Doch nicht alle Unternehmen entwickeln ihre Software bereits mit objektorientierten Technologien. Für viele "Late Movers" beginnt erst jetzt die Zeit des Umstiegs in eine völlig neue Art der Softwareentwicklung. Die hiermit verbundene Komplexität zu beherrschen stellen sich viele Unternehmen meist einfacher vor, als es sich dann in Pilotprojekten bewahrheitet. In diesem Vortrag werden einige typische und kostspielige Fallstricke für Einsteiger und Umsteiger in die objektorientierte Java Welt präsentiert, sowie Möglichkeiten aufgezeigt, von den viel gerühmten Vorteilen der "State-of-the-art" Softwareentwicklung auch wirklich zu profitieren. Dabei ist das Augenmerk nicht auf die Programmiersprache an sich gerichtet, sondern vielmehr auf das damit verbundene Umfeld und den Entwicklungsprozess. Vortragsfolien: A5_GEBIT.pdf
Softwaresysteme müssen immer wieder an neue und unvorhergesehene Anforderungen und Technologien angepasst werden. Agile Entwicklungsmethoden helfen dabei, Softwaresysteme dauerhaft änderbar zu gestalten, indem das softwaretechnische Design der Software ständig verbessert und die aktuellen Bedürfnissen angepasst wird. Den inneren Aufbau einer Software flexibel und änderbar zu halten ist allerdings keine triviale Aufgabe. Unter anderem müssen dazu Systemteile sauber voneinander entkoppelt werden und Abhängigkeiten zwischen verschiedenen Teilen eines Systems so stark wie möglich reduziert werden. Das Dependency-Injection-Muster ist ein Hilfsmittel, auch große Softwaresysteme in voneinander entkoppelte Einheiten zu zerteilen und Abhängigkeiten zwischen Systemkomponenten zu reduzieren. Ein erster Schritt dazu ist, die Abhängigkeiten zwischen Systemkomponenten explizit und von außen parametrisierbar zu machen. Das Dependency-Injection-Muster ist mittlerweile in einigen Open-Source-Frameworks realisiert worden. Der Vortrag gibt einen Einblick in den grundsätzlichen Aufbau des Dependency-Injection-Musters. Der Fokus des Vortrags liegt darauf, drei Frameworks zu vergleichen, die Dependency-Injection realisieren: Spring, PicoContainer und die Eclipse-Platform. Die Frameworks werden jeweils kurz charakterisiert und vor dem Hintergrund praktischer Projekterfahrungen bewertet. Die Teilnehmer erhalten so einen Überblick über die drei Frameworks und können einschätzen, welches der Frameworks sich für welche Art von Projekt eignet und wie es eingesetzt werden kann. Vortragsfolien: B5_it-agile.pdf
XML hat sich in den letzten Jahren zunehmend verbreitet. Vor allem bei Daten orientierter Nutzung von XML ergeben die Vorteile der definierten Struktur und leichten Lesbarkeit jedoch auch einen entscheidenden Nachteil: Das ungünstige Verhältnis zwischen der Größe des XML-Dokuments und den darin enthaltenen Nutzdaten. In diesem Zusammenhang beschäftigt sich auch das W3C in der "XML Binary Characterization Working Group" mit einer kompakteren, binären Variante von XML. Der auf der Diplomarbeit von Arthur Miskolczi basierende Vortrag gibt einen Überblick über Möglichkeiten der Kompression von XML und die derzeit am Markt verfügbaren bzw. kommenden Standards und Tools. Im Zuge der Diplomarbeit wurden verschiedener Kompressionstechniken bezüglich Datenvolumen und Prozessorlast bei der Verarbeitung analysiert. Im Vordergrund stand dabei die Optimierung der XML-Übertragung und -Speicherung auf Mobilgeräten. Die Ergebnisse dieser Analyse werden ebenfalls vorgestellt. Vortragsfolien: C5_PI-Data.pdf
Oft existieren zwar Dokumente über einzelne Geschäftsprozesse, diese werden aber nicht in die Softwareentwicklung integriert. Business-Modelle haben als Grundlage für die iterative Softwareentwicklung nachweisbare Vorteile: Sie schaffen eine einheitliche und prüfbare Basis und damit ein gemeinsames Verständnis für die zu schaffende Software, und sie bilden eine Kommunikationsplattform über bestehende und zukünftige Prozesse zwischen Fachabteilungen und Softwareentwicklern. Das Aufzeigen von Verbesserungspotenzial gehört ebenso dazu wie die Ableitung von Anforderungen an bestehende oder zukünftige IT-Systeme. Der Vortrag stellt die durchgängige Lösung einer Problemstellung von der Geschäftsidee, über die inhaltliche und technologische Verfeinerung bis hin zum Generieren von Code vor. An Hand eines praktischen Beispiels aus einem Kundenprojekt werden die Vorteile dieser Vorgehensweise demonstriert. Vortragsfolien: D5_MID.pdf
Seit Anfang des Jahres kommen J2EE1.4 basierte Applicationserver Plattformen auf den Markt. Am Beispiel von Oracle 10g und BeanConnect 2.0 sollen die neuen Möglichkeiten der darin enthalten JCA 1.5 Schnittstelle praktisch aufgezeigt werden. Die neue Connector Spezifikation bietet gleichberechtigte Integration von Alt und Neu mit umfassender Definition von Transaktions- und Securitykonzepten. Insbesondere ist nun auch die aktive Kommunikation (Inbound) vom Hostsystem zur J2EE Plattform möglich. Kommen damit neue J2EE Lösungen und etablierte Hostsysteme auf Augenhöhe? Vortragsfolien: E5_Fujitsu-Siemens.pdf
Komplexe Anwendungen stellen hohe Anforderungen an Entwicklung und Pflege, weshalb zunehmend modellgetriebene Ansätze zur Unterstützung herangezogen werden. Das Entwicklungswerkzeug "visual rules" vereint für die Entwicklung und Wartung von Geschäftslogik die Vorteile modellgetriebener Ansätze wie Model Driven Architecture (MDA) und Unified Modeling Language (UML) sowie der Business Prozess Modellierung (BPM) und der Rules Engines, ohne jedoch deren Einschränkungen aufzuweisen. "visual rules" unterstützt vielmehr den gesamten Entwicklungszyklus der Geschäftslogik. Die Handhabung ist dabei so einfach, dass auch Fachbereiche komplett in den Entwicklungsprozess einbezogen werden können und ihr Know-how über fachliche Anforderungen direkt beisteuern können. Die Geschäftslogik wird durch das entstehende Modell transparent, einfach wartbar, zudem automatisch in ablauffähigen Code umgesetzt und dokumentiert. Dies verbessert die Softwarequalität und beschleunigt gleichzeitig die Entwicklungszyklen, so dass die Geschäftslogik effizient auf geänderte Kundenanforderungen, Marktbedingungen oder Gesetzesänderungen angepasst werden kann. Der Referent wird auf der Basis umgesetzter Projekte aus den Bereichen Datenmigration, Online Transaktionsverarbeitung, Kundenselektion aufzeigen, für welche Anwendungsgebiete sich der vorgestellte Ansatz besonders eignet. Zudem wird der Ansatz zu den genannten Technologien abgegrenzt. Hierbei werden anhand konkreter Modell-Beispiele die einzelnen Schritte der Entwicklung von Geschäftslogik aufgezeigt:
Vortragsfolien: A6_Innovations.zip
Es werden leichtgewichtige Komponentenframeworks (wie z.B. Spring und PicoContainer) kurz vorgestellt. Ihre Konzepte und Eigenschaften, Benefits und Einschränkungen werden erläutert. Die unterschiedliche Bedeutung von POJOs (Plain Old Java Objects), Separation of Concerns, Inversion of Control, Dependency Injection und aspektorientierten Ansätzen in den ausgewählten Frameworks wird dargestellt. Die optimalen Einsatzmöglichkeiten der leichtgewichtigen Frameworks werden anhand eines Kriterienkatalogs abgegrenzt. Dabei werden die Dienste der einzelnen Frameworks vorgestellt, und dargestellt, welcher Overhead notwendig ist, um diese Dienste in Anspruch nehmen zu können. Welche Technologien (Tapestry, JSF, Struts, etc.) werden aktiv durch das Framework unterstützt, welche Lösungsalternativen und -szenarien werden empfohlen? Entstehen neue Abhängigkeiten zu Frameworkbestandteilen oder kann eine hohe Portierungsfreiheit erreicht werden? Diese Bewertung enthält einen Vergleich mit dem angekündigten EJB-Standard 3.0. Vortragsfolien: B6_Unilog-Avinci.pdf
Die Real-Time Specification for Java (RTSJ) ermöglicht die Verwendung von Java in zeitkritischen Anwendungen. Zeitkritische Anwendungen verrichten häufig Aufgaben die sicherheitskritisch sind, etwa die Steuerung eines Flugzeugs oder Satelliten. Für diese sicherheitskritischen Systeme ist eine Zertifizierung der RTSJ Implementierung und der Java-Anwendung erforderlich. Hierfür sind restriktive Profile nötig, die die Verwendung von nicht-zertifizierbaren Konstrukten verbieten. Vom Wissen über gefährliche Konstrukte und Wegen, diese zu umgehen profitieren auch herkömmliche Anwendungen, die etwa geschäftskritische Daten sicher verarbeiten müssen. Das europäische Projekt HIJA (High-Integrity Java, www.hija.info) hat im Juni 2004 mit der Definition und Implementierung von speziellen Profilen für Java für zukünftige vernetzte Echtzeitsysteme begonnen. Basierend auf den Funktionen in der RTSJ wird dabei ein sicherheitskritisches und ein geschäftskritisches Profil definiert. Diese Profile bieten eine eingeschränkte Untermenge der RTSJ mit dem Ziel, eine Zertifizierung bis zu DO178B level A zu ermöglichen. Die Aspekte des sicherheitskritischen Profils betreffen das Thread-Modell, Synchronisationsmechanismen, Speichermodell und Annotationen, die Werkzeugen ermöglichen, die Korrektheit zu verifizieren. Parallel dazu werden formale Verifikationswerkzeuge entwickelt um die funktionale und nicht-funktionale (Ressourcenverbrauch, etc.) Korrektheit einer Anwendung zu beweisen. Vortragsfolien: C6_aicas.pdf
Seit Beginn der 90er Jahre hat sich zunehmend die Notwendigkeit für die Integration von existierenden Softwaresystemen im Unternehmen oder über Unternehmensgrenzen hinweg ergeben. Ursprünglich wurden diese Anforderungen mit proprietären und aufwändigen EAI-Lösungen umgesetzt. Seit ungefähr zwei Jahren hat sich hierfür SOA als Standardarchitekturstil, mit Web Services als konkrete Lösung zu deren Implementierung, durchgesetzt. Die Vorteile von SOA bzw. Web Services gegenüber EAI liegen klar auf der Hand: technologieunabhängiger Standard für die Spezifikation und das Finden eines Services bzw. für die Kommunikation mit einem Service. Mit anderen Worten: Man hat mit Web Services ein Mittel um Softwaresysteme elegant zu verknüpfen, wobei eine lose Kopplung der Systeme im Vordergrund steht. Solange die Services rein funktional sind, bzw. deren Implementierung mit überschaubaren Datenvolumina realisiert werden kann, funktionieren Web Services hervorragend und haben sich in der Praxis bewährt. Werden große Datenmengen benutzt oder gar durch den Aufruf des Service übertragen, stoßen Web Services als konkrete SOA an ihre Grenzen. Der Einsatz eines objektorientierten Data Services adressiert genau diese Problematik. Hiermit kann zum einen die Implementierung eines Services, und zum anderen die datenintensive Kommunikation von Services untereinander stark verbessert werden. Im ersten Falle ergibt sich eine Performanzsteigerung der Implementierung im zweiten Falle eine bessere Nutzung der vorhandenen Übertragungsrate. In diesem Vortrag soll das Konzept der Data Services als Ergänzung zu Web Services innerhalb einer SOA vorgestellt und die zugrunde liegende Basistechnologie detailliert beschrieben werden. Vortragsfolien: D6_Persistence-Software.zip
Für den Zugriff auf eine Datenbank stehen in Java verschieden Technologien zur Verfügung: JDBC, EJB, JDO. Außerdem sind noch weitere in Planung: EJB 3.0. Doch welche sollten Sie für Ihr Projekt nutzen? Der Vortrag soll Ihnen helfen die verschiedenen Technologien einzuordnen. Vortragsfolien: E6_Versant.pdf
Wie kommt man einfach, sicher und möglichst schnell zu den persistenten Klassen einer Java-Anwendung? Indem man die Möglichkeit der Code-Generierung aus UML-Modellen in objectiF mit dem Java-Persistence Framework Hibernate kombiniert. Hibernate speichert Plain Old Java Objects als Tupel in einer relationalen Datenbank. Es unterstützt feinfühlige Mapping-Strategien von Klassenhierarchien und Assoziationen auf Tables und ForeignKeys. Für Mapping und Navigationstechniken verwendet Hibernate XML-Metafiles. Auf alle gängigen Datenbanksysteme kann Hibernate über JDBC zugreifen. Als äußerst effizient hat sich in der Praxis die folgende Vorgehensweise zur Entwicklung der Persistenzschicht einer Java-Anwendung erwiesen: Die Klassen des Anwendungsbereichs und ihre Assoziationen werden mit objectiF in Plattform-unabhängigen UML-Klassendiagrammen modelliert. Klassen und Assoziationen werden direkt in den Klassendiagrammen durch geeignete Stereotypen und dazugehörige Properties für die persistente Speicherung mit Hibernate markiert. Aus diesen so aufbereiteten Klassendiagrammen können gleich drei plattformspezifische Ergebnisse generiert werden:
Die generierten Java Source Files sind voll roundtrip-fähig zwischen dem UML-Modell in objectiF und dem Source-Code in der Eclipse-Workbench. Das UML-Modell und der Source-Code können so dauerhaft konsistent gehalten werden, bilden also nur zwei verschiedene Sichten auf dasselbe System. Diese Vorgehensweise wird im Vortrag live demonstriert: Es werden ein Klassenmodell modelliert, Klassen und Assoziationen als persistent markiert, Source-Code sowie XML-Metafiles generiert und Objekte in einer relationalen Datenbank gespeichert. Vortragsfolien: A7_microTOOL.pdf
Enterprise JavaBeans - die Komponententechnologie im J2EE-Kontext - geht mit weit reichenden Neuerungen in eine neue Runde. Man hat aus den Erfahrungen der Entwicklergemeinde gelernt und verfolgt mit der kommenden EJB 3.0-Version im Kontext von J2EE 5.0, die Hauptziele den Entwicklungsprozess und die Nutzung von EJB-Komponenten erheblich zu vereinfachen und zu beschleunigen. Schlagwörter wie beispielsweise POJO, POJI und Dependency Injection fließen technologisch in die EJB-Komponententechnologie ein und tragen zur Verbesserung und Vereinfachung des Komponentenmodells bei. Die Reduzierung der Anzahl der zu erstellenden Fragmente einer EJB-Komponente, Verwendung von Meta-Annotationen zur deklarativen Beschreibung von Typen und Eigenheiten und eine enorme Verbesserung der Persistenzabbildung sind einige der Hauptpunkte der Version 3.0. Dieser Vortrag bringt den Teilnehmern den aktuellsten Stand der kommenden Version der EJB-Technologie mit Informationen aus erster Hand durch ein Mitglied der EJB 3.0 Expert Group nahe Vortragsfolien: B7_Resco.pdf
Die Identifizierung von Produkten mit Hilfe von RFID (Radio Frequency Identification) findet zunehmend mehr Verbreitung. Ist nun RFID lediglich eine moderne Variante des Barcodes oder eine Technik, die die Privatsphäre und informationelle Selbstbestimmung akut bedroht? RFID liest mittels Radiosignalen Daten, die auf einem am Objekt angebrachten Transponder-Chip (Tag) gespeichert sind. Anders als beim Barcode können auch solche Tags gelesen werden, die sich innerhalb einer Verpackung befinden, zu denen also keine Sichtverbindung besteht. Ein Beispiel ist die automatisierte Warenannahme bereits bei der Durchfahrt eines LKW durch ein mit RFID-Lesegeräten ausgerüstetes Firmentor. Offensichtlich ergibt sich dadurch eine erhebliche Beschleunigung bei der Warenerfassung und nachfolgenden Geschäftsprozessen, wie der Warenwirtschaft oder Fertigung. Im Vortrag werden die technischen Möglichkeiten und Grenzen von RFID aufgezeigt. Es wird dargestellt, welchen Nutzen RFID beim Einsatz in der Produktion, der Lagerhaltung und der Logistik bringt. Die dazu notwendigen Komponenten einer RFID-Anwendungsarchitektur werden beschrieben und es wird auf den notwendigen Datenschutz, sowie Sicherheitsmaßnahmen, wie Authentifizierung oder Verschlüsselung eingegangen werden. Vortragsfolien: C7_Hewlett-Packard.pdf
Der heutige Software-Entwicklungsprozess ist vielschichtig, komplex und von ständig neuen Anforderungen begleitet. Dies erfordert Agilität und ein geeignetes Prozessmodell. Dieses Prozessmodell muss durch ein Werkzeug einfach bei der täglichen Arbeit Anwendung finden. Die EOS-Workbench bietet Unterstützung beim gesamten Softwareentwicklungsprozess, einschließlich den Subprozessen Projektmanagement, Konfigurationsmanagement, Risikomanagement, Qualitätssicherung, Nutzung und Bewertung. Der Vortrag erläutert das Zusammenspiel der nebenläufigen Prozesse im Projektumfeld, die Anwendung und den Nutzen der EOS-Workbench, sowie Einzelbeispiele für die Erstellung von Aktivitäten, Produkte, deren Kontrollfluss und Plankosten. Vortragsfolien: D7_cept-it.zip
Der Vortrag gibt einen technischen Überblick über die derzeit in Entwicklung befindlichen nächsten Releases der Java Plattformen. Insbesondere J2SE 6.0 (JDNC/JDIC, Web Services APIs) und J2EE 5.0 (EJB3.0, Common Persistence API und Java Server Faces) bilden den Fokus der Präsentation. Darüber hinaus wird aber auch auf zukünftige Themen, die die Weiterentwicklung von Java bestimmen, eingegangen. Vortragsfolien: E7_Sun.pdf
Enterprise Java architects and designers are now faced with an increasing number of persistence products that all promise ease of development, standardization and interoperability, scalability, and performance. These products include J2EE technology's Enterprise JavaBeans™ 2 architecture's CMP/BMP, JDO (Java Data Objects) implementations, leading proprietary solutions such as Oracle's TopLink and JBoss' Hibernate project, and most importantly the upcoming release of EJB™ 3.0 where these solutions will converge. This session will focus on the impact EJB 3.0 persistence on development, advice on how to prepare and migrate to this technology, and related initiatives surrounding development tools. Vortragsfolien: S8_ORACLE-TopLink.pdf
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
