zum aktuellen Java Forum Stuttgart
•
Kontakt
•
Impressum
 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
Abstracts zum 9. Java Forum Stuttgart
Service Orientierte Architekturen sind bekanntlich durch mehr als nur die Benutzung von Web-Services definiert, sie sind vielmehr eine Herangehensweise und ein Leitfaden der losen Kopplung innerhalb von Software Architekturen. Wie gestaltet sich dann aber das Management und die Kontrolle einer solchen lose gekoppelten Architektur und wie lässt sich eine Transparenz dieser Architektur erreichen? Wenn SOA mehr ist, als nur Web-Services, wie helfen dann Registries weiter ? Der Vortrag zeigt hierzu Mittel und Lösungen auf, wie anhand von Meta-Daten und Registries ein großer Schritt in Richtung "SOA Governance" erreicht werden kann. Vortragsfolien: A1_Scholz_SAG.pdf
Service Orientierung verschafft Ihrem Unternehmen Wettbewerbsvorteile! Gemäß Gardner, werden Service Orientierte Architekturen (SOA) künftig die Basis für mind. 80 Prozent aller neuen Entwicklungsprojekte bilden. Auch Ihr Unternehmen benötigt daher eine flexible Infrastruktur, um die Anwendungen in Echtzeit dynamisch verknüpfen zu können. Der Vortrag zeigt einen Überblick über die strategische Einführung einer SOA auf und vermittelt Ihnen das Rüstzeug für eine erfolgreiche Reaktion auf künftige Geschäftsanforderungen. Die konkrete Implementierung wird Ihnen anhand der vollständigen Produktpalette eines der Marktführer aufgezeigt. Vortragsfolien: A2_Keppeler_IBM.pdf
Sie werden in die neue Welt der Business Software Frameworks eingeführt - was ist ein Business Software Framework und was leistet es. Bison Solution ist ein solches J2EE basiertes Business Software Framework aus technologischen und funktionalen Komponenten, aus standardisierten Business Packages und Anwendungsprozessen, das für alles offen ist. Für Softwarehäuser jeder Herkunft und Branche, die schnell und mit hoher Qualität kunden- oder branchenspezifische Business Software entwickeln. Dadurch erübrigt sich eine Basisentwicklung und damit durchschnittlich rund 50 Mannjahre. Mittlere bis grosse Unternehmen profitieren von einem modernen Technologie- und Entwicklungs-Framework. Es ist bestens geeignet für flexible, hundertprozentig releasefähige und hoch anpassungsfähige Unternehmenslösungen und unterstützt die Prozesse der Wertschöpfungskette lückenlos. Mit Standard-Geschäftskomponenten, die sich einfach an individuelle Aufgaben und Anforderungen anpassen lassen. Vortragsfolien: A3_Seiler_BISON.pdf
Der neue Standard der Java-basierten Programmierung der serverseitigen Geschäftslogik ist da: POJO-basiert, leichtgewichtig, komponentenorientiert und mit einer Menge Vereinfachungen und Erleichterungen für die Implementierung von Java Enterprise-Applikationen versehen. Das EJB 3.0 Komponentenmodell unterscheidet sich massiv gegenüber den Vorgängerversionen und hat mit den damaligen schwergewichtigen Ansätzen nichts mehr gemein. Eines der Hauptmerkmale ist die innerhalb von EJB 3.0 entwickelte Persistenzabbildung - die Java Persistence API - die als Standard im Java EE und Java SE-Bereich zukünftig überall vorzufinden sein wird. Dieser Vortrag stellt den Teilnehmern im Überblick das mit umfassenden Neuerungen und Erleichterungen versehene Enterprise JavaBeans 3.0-Komponentenmodell und die Java Persistence API aus erster Hand durch ein Mitglied der EJB 3.0 Expert Group vor. Vortragsfolien: A4_Ihns_Resco.pdf
Eclipse has proven to be a very versatile, code centric development environment. It is very efficient for entering code, quickly fixing problems in syntax and semantics, refactoring, debugging, and other code manipulation tasks. An inevitable trend in the software development industry, however, is the quest for greater productivity and quality by using higher levels of abstractions to describe coding objectives. In the past, we have raised the abstraction level from machine code to higher level languages, like C, and from data structure descriptions to OOP as well as other such examples. Model Driven Architecture and Development is a next step in abstracting away from the CPU view of the computer and towards a high-level description, or abstraction of the system that we need to build. The Eclipse platform has much to gain and offer to this development paradigm. That's one of the reasons Compuware joined the Eclipse Foundation as a strategic member, bringing the benefits of MDA to the Eclipse platform. Vortragsfolien: A5_Schoenhage_Compuware.pdf
Serviceorientierte Architekturen (SOA) sind in aller Munde und sind aufgrund ihrer Flexibilität und Modularisierung die strategisch richtige Entscheidung für die IT-Landschaft der Zukunft. Die SOA-typische schematische Sicht auf einzelne Komponenten lässt allerdings oft vergessen, dass auch SOA auf bewährten Java-Technologien beruht. Trotz (oder auch wegen) des Einsatzes von codegenerierenden Tools und Frameworks ist es für den Entwickler im SOA Zeitalter wichtiger denn je, die verwendeten Technologien und Standards zu kennen und zu verstehen. Das Curriculum der IBM SOA-Trainings umfasst alle Ebenen der serviceorientierten Architektur und ist daher die ideale Grundlage für gut ausgebildete Entwickler und einen erfolgreichen Start in die SOA-Welt. Vortragsfolien: A6_Armbruster_IBM.pdf
Die Nutzung mehrerer Rechner im Netzwerk in Clustern oder - in größerem Maßstab - in Grids gewinnt auch im J2EE Umfeld zunehmend an Bedeutung. Dazu existieren verschiedene Ansätze die zugrunde liegende Hardware nutzbar zu machen. Virtualisierung, Automatisierung und Grid Technologie sind dabei die Eckpfeiler eines J2EE basierten Rechenzentrumsbetriebs. Mit FlexFrame für Oracle verbinden sich Infrastrukturtechnologie von Fujitsu-Siemens Computers in hervorragender Weise mit der Grid Softwaretechnologie von Oracle 10g. Vortragsfolien: A7_Vorsamer_FujitsuSiemens.pdf
Die Phasen der Softwareentwicklung sind in unterschiedlichen Vorgehensmodellen und Best Practices ausführlich beschrieben. Insbesondere für die Java-Entwicklung existiert eine Vielzahl von Techniken und mehr oder weniger frei verfügbare Tools zur teil- oder vollautomatisierten Abdeckung der Entwicklungsphasen (Maven, Ant, JUnit). Eclipse integriert und unterstützt diese Techniken mit jedem Release immer besser, sodass dem Entwickler inzwischen eine hoch integrierte Toolkette zur Verfügung steht. Wenige Projektteams sind allerdings bisher in der Lage, jederzeit und ohne größeren Aufwand einen zuverlässigen Statusbericht ihres aktuellen Projekts abzugeben. Um den Bearbeitungsstand einer bestimmten Änderungsanforderung zu sehen, muss oft erst der zuständige Entwickler kontaktiert werden, wobei vielfach noch immer Excel-Sheets eingesetzt werden, deren Aktualität nie sicher gestellt werden kann. Übersichtliche Darstellungen und Auswertungen müssen zumeist manuell erstellt werden, wobei der Aufwand zur Anschaffung, Einführung und Einsatz bei der täglichen Arbeit in keinem Verhältnis zum erzielten Nutzen steht. Dieser Vortrag stellt ein Szenario unter Verwendung von Eclipse und der MKS Integrity Suite vor. Es wird gezeigt, wie Reibungsverluste in der Prozesskette minimiert und Daten für wichtige Metriken erfasst und ausgewertet werden. Dabei kann jederzeit der Zustand von Anforderungen in der Entwicklung bis hin zur Auslieferung eingesehen werden. Integrationspunkte in wesentliche Standardtools werden aufgezeigt (ANT, JUnit, Eclipse IDE generell) und mögliche Effizienzverbesserungen identifiziert. Schließlich wird exemplarisch gezeigt, wie ein Übergabestand (Hotfix, Patch, Pre- oder Major-Release) mit einem vollständigen Nachweis über umgesetzte Anforderungen, Änderungsanforderungen oder Fehlerbehebungen versehen werden kann. Vortragsfolien: B1_Braeuchle_MKS.pdf
MDD wird wie MDA häufig mit den Zielen Portabilität und Interoperabilität verknüpft. objectiF setzt einen anderen Schwerpunkt: Erhöhung der Entwicklungsgeschwindigkeit durch Abstraktion & Automation. Ziel von objectiF ist es, die Geschwindigkeit der Softwareentwicklung - bei garantiert hoher Qualität - nachhaltig zu steigern, indem die Softwareentwicklung vom Code-Niveau auf eine höhere Abstraktionsebene - auf Modellniveau - verlagert und anschließend das Modellwissen maschinell in Code umgesetzt wird. Bei MDD mit objectiF sind Modelle mehr als Dokumentation. Aus den Modellen für die fachliche Spezifikation werden durch Transformationen automatisch Design-Modelle für die technologische Zielplattform erzeugt. Diese sind Basis und Vorgabe für die Code-Generierung. Die Modelltransformationen sind wiederholbar. Das heißt, neue Anforderungen können direkt in die fachliche Spezifikation eingearbeitet werden, das technische Design folgt immer der fachlichen Vorgabe. 4 Schritte von MDD mit objectiF:
Vortragsfolien: B2_Ehlert_microTOOL.pdf
Unter hohem Kosten- und Erfolgsdruck müssen heutzutage Software-Lösungen geplant, entwickelt und eingeführt werden. Nur selten hat man es mit isolierten Systemen zu tun, meist muss die Integration in eine heterogene Anwendungslandschaft erfolgen. In diesem Vortrag wird ein voll werkzeugunterstützter modellbasierter generischer SW-Entwicklungsprozess auf Eclipse Basis vorgestellt, der durch Testframeworks in hohem Maße qualitätsgesichert wird. Zahlreiche Projektreferenzen manifestieren die kurzen Entwicklungszyklen und eine hohe Qualität der ausgelieferten Software. Im zweiten Teil rundet eine Demonstration des Round Trips den Vortrag ab. Vortragsfolien: B3_Sauer_GEBIT.pdf
Der Vorgang der Anforderungserhebung ist oft unerfreulich, teuer und liefert unbrauchbare Ergebnisse. In dieser Situation wurden nicht nur die Anforderungen uneffektiv erstellt, sondern das ganze Projekt ist so zum Scheitern verurteilt. Die kompromisslose Suche nach der effektivsten Kommunikationsform und die Rückbesinnung auf agile Tugenden hilft, den Verständnisgraben zwischen Fachabteilung und IT zu überbrücken und ermöglicht so, Anforderungen sinnvoll zu erheben. Mit der vorgestellten Methode können Anforderungen kompakt, valide und in kürzester Zeit erstellt werden. Damit ist der Grundstock für ein erfolgreiches Projekt gelegt. Handout: B4_Handout.pdf
SOA und BPM sind in aller Munde - der Fokus wird hier häufig nur auf die Einbindung und Integration der bestehenden Backendsystemen gelegt, der klassische EAI Ansatz. Dabei kommt es in einem Geschäftprozess nicht nur darauf an, ein Datenpaket von Service A nach Service B zu transportieren, entscheidend ist, wie der Anwender mit dem Prozess interagieren kann. In den letzten Jahren wurden hierfür Webapplikationen und Portale eingesetzt. Diese haben aber die bekannten Nachteile der schwierigen Integration mit dem Desktop des Anwenders. Bestehende Desktop Applikationen wie Office, Outlook, Lotus Notes, usw. können häufig nicht vollständig in die Webapplikationen integriert werden, dadurch leidet die Ergonomie und die Produktivität. Die Eclipse Rich Client Plattform kann hierfür einen Lösungsansatz bieten. Die Cenit hat deshalb mit ihrem Produkt eWorks einen Postkorb Client auf Basis der Eclipse Rich Client Plattform erstellt. Der Plugin Mechanismus der Eclipse RCP war entscheidend für die Wahl der Client-Technologie. Mit eWorks ist es für den Anwender möglich einen Geschäftsprozess komplett ohne Medienbruch zu bearbeiten. Somit kann die Produktivität in der Vorgangsbearbeitung erheblich gesteigert werden. Um flexibel auf Änderungen am Geschäftsprozess reagieren zu können, wird der Client vom Server aus gesteuert. Der Workflow gibt vor, welche Masken oder Applikationen für die Bearbeitung verwendet werden sollen. In dem Vortrag wird dargestellt wie der Plugin Mechanismus von Eclipse verwendet werden kann, um eine clientseitige Integrationsplattform für ein BPM System zu erstellen. Anhand von eWorks wird gezeigt, wie mit Hilfe des Spring Frameworks und Eclipse RCP eine solche Client Lösung umgesetzt werden kann. Vortragsfolien: B5_Guenther_CENIT.pdf
In Anbetracht vieler unterschiedlicher Technologien und einer sich ständig ändernden Softwarelandschaft setzen mehr und mehr Unternehmen auf Service-Orientierung. Dabei zeichnet sich ab, dass der Service-Infrastruktur-Layer entscheidende Technologien bietet, die serviceorientierte Architekturen erst ermöglichen. Die bedeutendste Technologie dürfte der Enterprise Service Bus (ESB) sein. BEA AquaLogic Service Bus liefert die service-orientierte Infrastruktur für eine flexible, leistungsfähige IT, die sich auf die betrieblichen Erfordernissen ausrichtet und sorgt für die nahtlose Konvergenz zwischen den Integrationsfähigkeiten eines Enterprise Service Bus mit dem Service-Management. Das beschleunigt die Konfiguration und Implementierung und vereinfacht das Management von gemeinsam genutzten Services innerhalb der gesamten SOA. Der AquaLogic Service Bus bietet intelligentes Message Brokering, dynamisches Routing und Transformationen, unterstützt die verschiedensten Services und integriert Service-Lifecycle-Management-Fähigkeiten wie Service-Registrierung, Monitoring und die Schwellwert-definierte Durchführung von Service-Level-Agreements (SLA). Zudem werden Sie erfahren, wie eine Service Registry zur Einrichtung einer Unternehmens-SOA mit dem ESB kombiniert werden kann, wie sie die Steuerung und das Lifecycle-Management der SOA unterstützt, und wie sich ihre Aufgaben und Funktionen verändern, wenn Unternehmen mehr und mehr Gebrauch von Ihrer SOA machen. Vortragsfolien: B6_Weigend_BEA.pdf
In dem Vortrag wird vorgestellt wie man schrittweise eine Service Orientierte Architektur für sein Unternehmen aufbauen kann. Die Schritte werden an Kunden-Beispielen erläutert und dargestellt. Mit Hilfe der Kunden-Beispielen werden verschiedene Wege aufgezeigt wie man in die SOA einsteigen kann. Vortragsfolien: B7_Trops_ORACLE.pdf
Die Entwicklung von Rich Internet Applikation (RIA) soll dem Anwender einer Browseranwendung das Gefühl geben, mit einer normalen Desktopanwendung zu arbeiten. Um dies zu erreichen, muss die transaktionsorientierte Arbeitsweise von "normalen" HTML bzw. JSP Seiten im Browser durch Techniken ersetzt werden, mit deren Hilfe direkt (ohne Neuladen der kompletten Seite) auf Benutzereingaben reagiert werden kann. Die Kombination von AJAX als Kommunikationsebene und den DHTML Komponenten HTML, Javascript, CSS und DOM ermöglichen es, das Look-and-Feel von Desktop-Anwendungen im Browser zur Verfügung zu stellen. Das Framework DRUIDE versetzt JAVA-Entwickler in die Lage, ansprechende und komplexe Webanwendungen erstellen zu können, ohne dass Schulung und Einarbeitung in Web-Techniken notwendig ist, da DRUIDE diese innerhalb des Frameworks verbirgt. Vortragsfolien: C1_Polm_GHS.pdf
This session will present ILOG JViews, a family of individual Java products designed to help Java developers build advanced types of highly-graphical interactive displays (charts, diagrams, Gantt charts, maps, communication networks and military preparation of mission). They are ideal for developing data-aware, rich GUIs that offer high-performance, portability, and intuitive operation -- as well as connecting to databases and synchronizing. Each product can be used independently or in combination with the others (or with third-party products) to produce rich user interfaces for applications, applets, or web thin-clients. ILOG JViews comes with a Designer application that allows developers to specify how the display will look using a point-and-click editor, rather than via Java coding. Flexibility is not sacrificed at the expense of ease-of-use. All ILOG JViews products are delivered with an SDK, a completely detailed and fully documented API that enables deep customization for implementing the exact requirements. Because it is based on Swing and Java2D, ILOG JViews is ready for Java-based applications, applets and Web Start applications. Rich web applications requiring diagrams, graph, network or charts can embed AJAX-enabled JavaServer Faces (JSF) components from ILOG JViews. Vortragsfolien: C2_Mouly_ILOG.pdf
Das Rich AJAX Platform-Projekt (RAP) ermöglicht die Erstellung von AJAX-fähigen Webapplikationen mit dem von der Eclipse Rich Client Platform bekannten Entwicklungsansatz. RCP hat sich bei der Entwicklung von flexiblen, erweiterbaren Applikationen mit hohem Benutzerkomfort bewährt. RAP implementiert den Großteil der aus RCP bekannten API für Web-Applikationen, es ist sozusagen ein RCP für Webapplikationen. Das bedeutet unter anderem, dass es möglich sein wird, einen Großteil des existierenden Codes auch für eine Darstellung im Web zu nutzen. Bzw. werden RAP Applikationen ohne Änderungen als RCP - Applikationen lauffähig sein. RAP basiert auf drei Bausteinen: Ein Widget-Toolkit, den Plug-in-Mechanismus und eine Workbench - alle drei Bausteine werden innerhalb einer Web-Applikation ausgeführt. Für das Widget-Toolkit funktioniert das ähnlich wie bei SWT: Eine Java-Komponenten-Bibliothek schirmt den Entwickler gegenüber den benötigten Basis-Technologien ab. Für den Plug-in-Mechanismus bei Webapplikationen benötigt man die OSGi-Funktionalität innerhalb der Webapplikation. Die Workbench, also der Mechanismus, der die UI-Kontributionen der einzelnen Plug-ins integriert, ist eng mit dem Widget-Toolkit verwoben. Innoopract hat das RAP Projekt im März bei Eclipse vorgeschlagen und wird eine signifikante Kontribution von Sourcecode leisten, die bereits einen Großteil der Herausforderungen des Widget-Toolkits abdeckt und sofort einsetzbar sein wird. In diesem Vortrag wird Innoopract die Technologie des RAP-Projektes vorstellen und zeigen wie man AJAX Web Applikationen im Eclipse Workbench Stil effizient mit RAP erstellen kann. Mehr Info zur RAP und eine Demoapplikation befinden sich bei http://eclipse.org/proposals/rap Vortragsfolien: C3_Krause_INNOOPRACT.pdf
Mit JavaServer Faces kam im April 2004 der offizielle Standard hinsichtlich eines UI-Frameworks auf den Markt. Seitdem entwickelt sich ein ständiges steigendes Interesse an JSF. Einen Makel scheint JSF jedoch zu haben: Es ist für die JSP-Seitenerstellung wieder eine neue Tagsyntax notwendig. Mit Facelets wird diese Hürde entscheidend verkleinert. Facelets ermöglicht es, ähnlich wie bereits bei Tapestry realisiert, Html-Seiten mit zusätzlichen Attributen zu versehen, um damit voll funktionsfähige JSF-Seiten zu erzeugen. Der Vorteil liegt darin, dass JSF-Seiten mit gewöhnlichen Html-Editoren bearbeitet werden können, im Hintergrund jedoch das mächtige Framework JSF zum Einsatz kommt. Doch Facelets bietet weit mehr: So werden einige Schwachstellen im Umgang mit JSP-Seiten beseitigt und es existiert ein sehr mächtiger Templating-Mechanismus. Vortragsfolien: C4_Bosch.pdf
Wenn ein Debugger benutzt wird, liegt das Augenmerk des Entwicklers normalerweise auf der zu behebenden Fehlersituation. Ist ein Fehler jedoch einmal aufgetreten, erlauben Debugger üblicherweise nicht, die Ereignisse nachzuvollziehen, die zu diesem Fehler geführt haben. Beispielsweise bieten Debugger keine Unterstützung dafür, beim Auftreten einer NullPointerException automatisiert festzustellen, wo die fehlerhafte Nullreferenz herkommt - wann wurde die betreffende Variable zuletzt geschrieben, und wieso wurde an sie null zugewiesen? Als Programmierer ist man in solchen Fällen darauf angewiesen, die Fehlerursache durch das Setzen von Breakpoints und schrittweise Programmausführung mühsam herauszufinden. Ein "Zurücklaufen" in der Ausführung ist nicht möglich. Das von Bil Lewis zuerst vorgestellte Konzept des "Omniscient Debugging" (OD) erlaubt es dem gegenüber, die Ausführung eines bereits beendeten Programmlaufs Schritt für Schritt nachzuvollziehen und dabei die Werte einzelner Variablen und Objekteigenschaften genau zu beobachten. Auf diese Weise wird es möglich, Fehlerursachen direkt aufzufinden. Am Fachgebiet Softwaretechnologie der TU Darmstadt wurde ein Eclipse-Plugin für OD entwickelt. Zusätzlich zu den OD-Fähigkeiten bietet "Backtrac" die Möglichkeit, so genannte "Slices" zu berechnen, also die Stellen im Quelltext zu markieren, die Einfluss auf eine bestimmte Anweisung haben, oder die von ihr beeinflusst werden. In der Summe ergibt sich ein mächtiges Werkzeug zur Fehleranalyse in Java-Programmen. Vortragsfolien: C5_Haupt_TUDarmstadt.pdf
Um schnell und zuverlässig auf Software-Requirements reagieren zu können muss vor allem Transparenz in den Stand der Software-Entwicklung sowie deren Qualität und damit Releasefähigkeit gebracht werden. Agitar setzt mit dem Agitator und dem Management Dashboard genau an diesem Punkt an. Der Agitator unterstützt den Entwickler bereits bei der Erstellung seines Codes und gibt ihm sofort Feedback, wie sich der geschriebene Code zur Laufzeit denn wirklich verhält. Er nimmt also die Rolle des "Pair Programmers" ein, den wir aus XP von Kent Beck kennen. Das Feedback, die sogennante "Observation", kann per Mausklick zum persistenten Testfall definiert werden und wird bei jedem "Agitation Run" als Regressionstests durchlaufen. Das Management Dashboard verarbeitet die Resultate des Agitators und präsentiert diese auf einfache und verständliche Weise (auch dem Management). Dabei werden zusätzliche Metriken, wie z. B. die Komplexität und das Risiko sowie Coding Conventions auf Klassenebene erhoben bzw. überprüft. Durch die Kombination beider Tools können Qualität und Effizienz in der Softwareentwicklung signifikant gesteigert sowie kürzere Releasezyklen in Kombination mit Continious Integration erzielt werden. Das Aufsetzen einer Testumgebung mit JUnit entfällt zum größten Teil. Vortragsfolien: C6_Hildebrandt_Agitar.pdf
In zunehmend komplexer werdenden Umgebungen zum Betrieb von Enterprise-Anwendungen wird die Suche nach Problemen und Fehlern immer mehr zur Herausforderung. Gründe für die hohe Komplexität der Systemumgebungen sind einerseits Anforderungen an Redundanz und Hochverfügbarkeit sowie andererseits die Vielzahl zu bedienender Schnittstellen zu Drittsystemen. Für das Auffinden von Problemen und Fehlern in Enterprise-Anwendungen werden Profiling- und Monitoring-Verfahren eingesetzt. Beide erlauben einen Einblick in laufende Systeme und ermöglichen so Diagnosen, die Ansatzpunkte zur Verbesserung liefern. Schwerpunktmäßig werden solche Verfahren im Bereich der Applikationsserver und der Datenbanksysteme eingesetzt. Dieser Beitrag stellt verschiedene Verfahren für die Überwachung und Untersuchung von J2EE-Applikationsservern vor und bewertet deren Tauglichkeit in verschiedenen Problemszenarien. Zu den untersuchten Verfahren gehören Bytecode-Modifizierende bzw. aspektorientierte Ansätze, Profiling und JMX. Diese genannten Verfahren wurden von uns auf ihren Nutzen in verbreiteten Problemsituationen, beispielsweise bei ungenügendem Antwortzeitverhalten, untersucht und miteinander verglichen. Ergebnis ist eine Empfehlung, welche Vorgehensweise für welche Analysen am besten geeignet ist. Vortragsfolien: C7_Wanner_HTS.pdf
Eclipse Rich Client Platform (RCP) is a runtime platform for delivering your Java applications on multiple platforms. RCP is far more than just a widget toolkit; it is effectively rich client "middleware" that provides a comprehensive framework for building and deploying applications that are modular, extensible, and updatable. Eclipse Rich Client Platform (RCP) was released as part of the Eclipse 3.0 platform in an effort to formalize what some organizations had been already been doing with earlier versions: using the richness of the open source Eclipse platform to deliver high quality applications that provide rich user experiences. Since then, numerous organizations (including NASA, IBM, and Novell) have started to leverage Eclipse as the delivery platform for their own applications. As Eclipse continues to evolve, so does the support for building rich client applications. During this session, through a combination of presentation and demonstration, we will show you how you can leverage Eclipse 3.2 along with the entire Eclipse eco-system to build and deploy rich client applications targeting multiple operating systems (Linux, UNIX, MacOS, Windows, and mobile devices). Vortragsfolien: D1_Beaton_EclipseFoundation.pdf
Mit EMF kann man auf pragmatische Art und Weise modellgetrieben Software entwickeln. Ein großer Vorteil von EMF ist, dass die Entwickler parallel am Modell und am Code arbeiten können. Der Vortrag gibt einen Überblick über EMF und seine Bestandteile. Wir erklären das Metamodell "ECore" und die Struktur des generierten Codes. Die Werkzeugunterstützung demonstrieren wir an einem praktischen Beispiel. Vortragsfolien: D2_Gerhardt_Moroff_Eberle.pdf
Dieser Vortrag stellt das Texteditor-Framework von Eclipse vor und demonstriert, wie damit ein umfangreicher Quelltexteditor programmiert und in die Eclipse Entwicklungsumgebung oder in eine Rich Client Anwendung integriert wird. Ob für die Konfigurationsdatei des Servers oder die experimentelle Sprache der Forschungsabteilung - ein leistungsfähiger Editor hilft Benutzern, schnell korrekten Quelltext zu schreiben. Wir lassen den Inhaltsassistenten Komplettierungsvorschläge inklusive Schablonen (Templates) anzeigen, falten Teile der Dokumentstruktur und verfolgen die Änderungen gegenüber dem Revisionssystem. Der Quelltext wird mit Fehler- und Warnungs-Annotationen versehen und Quick Fix bietet Lösungen für oft wiederkehrende Probleme. Viele dieser Funktionen benötigen ein semantisches Textmodell, das wir mit einem einfachen Parser erstellen und laufend aktualisieren. Im Vortrag analysieren wir die Voraussetzungen der genannten Schlüsselfunktionen und zeigen, wie sie im Texteditor-Framework implementiert werden. Vortragsfolien: D3_Eicher_IBM.pdf
Die Eclipse-Rich-Client-Platform hat gezeigt, dass sich weite Teile der Eclipse-Technologie gewinnbringend für normale Business-Anwendungen einsetzen lassen. Wie der Name der Plattform schon vermuten lässt, konzentriert sich die RCP allerdings auf die Implementation von Rich-Client-Anwendungen. Heutige Anwendungssysteme werden allerdings schon lange nicht mehr als reine Rich-Client-Anwendungen entwickelt. Häufig kommt ein Server zum Einsatz, der dem Klienten Aufgaben abnimmt - wie in einer typischen Multi-Tier-Architektur üblich. Teilweise verzichten größere Systeme sogar völlig auf einen Rich-Client - entweder, weil ein ausschließlich web-basiertes Front-End implementiert wird (mit Web 2.0 erlebt das web-basierte Front-End ja wieder eine Renaissance) oder weil die Anwendungen überhaupt kein interaktive Front-Ends benötigen, da es sich um reine Back-End-Anwendungen handelt. In diesem Vortrag werfen wir einen genaueren Blick darauf, warum die Eclipse-Technologie im nächsten Schritt die Server-Seite erobern wird und welche Möglichkeiten es gibt, Eclipse schon heute für server-basierte Anwendungen zu nutzen. Vortragsfolien: D4_Lippert.pdf
JUnit 4 wurde im Februar 2006 von Kent Beck und den anderen beteiligten Personen veröffentlicht. Der Vortrag führt in die neuen Features von JUnit 4 ein, die auf JDK 5 und Annotations beruhen. Er beschreibt die neuen Features kurz anhand von kompakten Beispielen. Es wird auf die Kompatibilität von existierenden Testcases und dem neuen Framework eingegangen. Zusätzlich wird das neue Implementierungs Design von JUnit 4 vorgestellt, sowie exemplarisch gezeigt, wie man mit dem neuen API auch eigene Ergänzungen daran vornehmen kann. Beispiele dazu liegen als OpenSource Projekt vor. Vortragsfolien: D5_Hiller.pdf
Magnolia ist ein Open Source CMS, das vollständig auf dem neuen Standard für Java Content Repositories (JSR-170) basiert. Dadurch ist es zukunftsorientiert und flexibel auch für eigene Entwicklungen einsetzbar:
Eine Einführung in den Standard JSR-170 erläutert die Basis der Magnolia Entwicklung. Wir werden im Rahmen einer Demo die wesentlichen Eigenschaften von Magnolia zeigen. Dabei wird die besonders auf Benutzerfreundlichkeit ausgelegte Plattform erläutert und gezeigt, wie diese für eigene Entwicklungen angepasst und erweitert werden kann. Auf Basis der standardmäßig mitgelieferten Templates und Paragraphen werden wir mit Magnolia einen kompletten Webauftritt erstellen und um eigene Funktionalitäten erweitern. Hierzu werden wir ein neues Template und einen neuen Paragraphen erstellen und in dem Webauftritt integrieren. Ein Ausblick auf neue Entwicklungen und geplante Erweiterungen wird den Vortrag beschließen. Vortragsfolien: D6_Hirning_Unilog.pdf
Mit dem JSR-241 ist Groovy die zweite standardisierte Sprache für die Java Plattform geworden (neben der Java Sprache selbst). Der Vortrag gibt einen Überblick über die Konzepte von Groovy und konzentriert sich auf die Frage, wie Java-Entwickler in typischen J2EE-Projekten von Groovy profitieren können. Durch die nahtlose Integration mit Java ist Groovy nicht bloß auf die typischen Skripting-Aufgaben beschränkt, sondern kann prinzipiell benutzt werden, um jeden beliebigen Anteil einer J2EE-Anwendung zu programmieren. Dabei sind erhebliche Produktivitätsgewinne durch die mächtigen Groovy-Sprachkonzepte und -Bibliotheken möglich. Groovy bringt die Einfachheit zu Java zurück. Nach dem Vortrag wissen die Teilnehmer, was Groovy ist und welche Möglichkeiten der Integration in ihre Java-Projekte existieren. Vortragsfolien:
Über 70% aller Angriffe erfolgen heute über Schwachstellen im Anwendungsdesign oder in der Implementierung, nicht über Netzwerke. Somit sind "Application Attacks" die größte Gefahr für E-Business, da sie zudem von Firewalls, SSL und anderen herkömmlichen Technologien nicht blockiert werden können. Nur das richtige Design und die korrekte Implementierung einer Anwendung kann einen verlässlichen Schutz bieten. 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: E1_Sams_OPTIMAbit.pdf
Ein neues Paradigma deutet sich am Horizont der Entwicklungs-Methoden an: die Aspektorientierte Programmierung (AOP). Was aber genau macht AOP aus? Ist es ein nur ein neuer akademischer Ansatz aus dem Elfenbeinturm oder taugt er auch für die Praxis? Dieser Vortrag gibt anhand einer kleinen Fallstudie mit AspectJ einen ganz kurzen Einblick in die wunderbare Welt der Aspekte, ehe er von Erfahrungen aus einigen AOP-Projekten berichtet. Zurückhaltung und einige einfache Regeln, gepaart mit der richtigen Einführungsstrategie, helfen dabei, Misserfolge in Pilot-Projekten zu vermeiden. Vortragsfolien: E2_Boehm.pdf
Service-orientierte Architekturen werden zurzeit als der Schlüssel für die flexible Integration von Anwendungen zur Unterstützung agiler Geschäftsprozesse gesehen. Allerdings gestaltet sich der Aufbau konkreter SOA komplexer, als gemeinhin angenommen. Dies gilt besonders dann, wenn die Anzahl der zu integrierenden Dienste mehr als eine Handvoll beträgt. Skalierbare, wartbare Service-orientierte Architekturen erfordern daher als Unterbau einen Enterprise Service Bus (ESB). Ein derartiger ESB muss z.B. die teilnehmenden Services bezüglich der Transportprotokolle und konkreter Endpunktadressen voneinander entkoppeln, einfach zu verwalten sein und die technische Hürde für die Teilnahme weiterer Dienste vermindern. Gleichzeitig bestehen konkrete nicht-funktionale Anforderungen an die ESB-Infrastruktur: Stichworte sind Skalierbarkeit, Unabhängigkeit von bestehenden Serversystemen und eine flexible Architektur, die sich an die sich rasant ändernden Standards anpassen lässt. Der Vortrag erläutert Anforderungen an einen modernen Enterprise Service Bus, zeigt anhand der KOMPASS-Infrastrukturkomponente (KIK), wie sich ein entsprechender SOA-Baustein auf der Basis von OpenSource-Produkten (JBoss, Spring, AndroMDA, Hibernate etc.) entwickeln lässt und stellt eine Referenzarchitektur vor. Vortragsfolien: E3_Borgmeier_syngenio.pdf
Trotz modellgetriebener Softwareentwicklung und deren Codegenerierung müssen bei jedem Projekt Codeteile von Entwicklern geschrieben werden. Aus verschiedenen Gründen werden dabei bereits umgesetzte Algorithmen neu erarbeitet und programmiert. Damit wird der Vorteil der Widerverwendbarkeit verschenkt. Das erkannten auch die Entwickler innerhalb des Jakarta Projekts und lagerten häufig benötigte Codeteile in eigene Bibliotheken aus, die Jakarta Commons. Dadurch entstanden autonome Komponenten, die mittlerweile auch außerhalb von Jakarta zum Einsatz kommen. Der Vortrag gibt einen Überblick über die verschiedenen Komponenten und deren Einsatzbereiche. Abgerundet wird die Präsentation durch eine detaillierte Betrachtung von in eigenen Projekten verwendeten Bibliotheken. Anhand konkreter Problemstellungen wird gezeigt, wie mit Hilfe von Jakarta Commons schnell elegante Lösungen erstellt werden konnten. Vortragsfolien: E4_Wagner_Signsoft.pdf
In the past several years, the Java programming language has proven itself superior to C and C++ for the maintenance and development of traditional information processing applications. To use Java effectively in the real-time domain, a number of important issues must be addressed. Recent successes in the use of Java for real-time applications has demonstrated that these issues can be effectively addressed through a combination of special development tools, special Java virtual machine implementation techniques, and programming discipline. Different approaches are recommended for soft real-time, hard real-time, and safety-critical development. This presentation surveys the differences between these specialized application domains and explains the practices that make it possible to satisfy the specialized requirements of each domain. Unlike much of the early experimentation with the use of Java in real-time systems, application of these practices makes it possible to exploit important Java strengths that have made this language so successful in traditional information systems. Among the key Java benefits that are preserved within the real-time development framework are included ease of development and maintenance, reliability, portability, reuse, and scalability. Vortragsfolien: E5_Nilsen_Aonix.pdf
Die für Java bevorzugt eingesetzten Datenbankabfragesprachen (SQL, EJBQL) sind Fremdkörper in Java Applikationen. Eingebettete Zeichenketten (Strings) sind nicht nur für Java-Entwickler eine Fremdsprache, auch der Compiler versteht sie nicht, mit allen daraus resultierenden Nachteilen: Abfragen werden während des Kompilierens nicht überprüft. Automatisches Refakturieren ist nicht möglich. Objektorientierung wird nicht unterstützt. In diesem Vortrag werden Native Queries vorgestellt, eine Syntax um Datenbankabfragen in reinem Java zu formulieren. Carl Rosenberger, Chief Software Architect der OpenSource Objektdatenbank db4o, beschreibt den Aufbau von Native Queries, erläutert die Verwendung in der Praxis anhand von Beispielen und beschreibt die Vorteile die sich durch den Einsatz von Native Queries für die Anwendungsentwicklung ergeben. Vortragsfolien: E6_Rosenberger_db4objects.pdf
In diesem Jahr steht mit Java 6 das nächste große Release der Java Plattform bevor. In diesem Vortrag widmen wir uns den Details der neuen Version. Genauer betrachtet werden insbesondere die XML & Web Services APIs, die Erweiterungen im Desktop Java Umfeld, Java und Scripting Integration sowie generelle Arbeiten an der JVM bezüglich Performance, Montoring und Troubleshooting. Vortragsfolien: E7_Adelhardt_Sun.pdf
|
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
