Forgot your password?

Conference slides of S&S Media Group
until september 2019

Register

  • By sending the registration you confirm our general terms and conditions and data protection regulations.

DIREKT BESTELLEN

Bestehendes Abonnement zum entwickler.kiosk-Zugang erweitern

Bitte wählen Sie Ihr bestehendes Abonnement:

Volltextsuche

Ihre Suchergebnisse für:

No content found!

W-JAX 2012

Die W-JAX bildet gemeinsam mit der JAX Europas führende Konferenz-Serie für Enterprise-Technologien, agile Methoden und Softwarearchitekturen. Gemeinsam mit den begleitenden Business Technology Days verleiht sie IT-Professionals aus Unternehmen aller Branchen die entscheidenden Impulse für digitale Wertschöpfung und Innovation – zwei Mal im Jahr.

Mehr als 160 international renommierte Speaker geben in rund 180 Vorträgen ihr Erfahrungswissen an die Teilnehmer weiter. Verständlich, praxisnah und erfolgsorientiert. Dabei thematisiert die W-JAX eine große Bandbreite aktueller und zukunftsorientierter Technologien von Java über Scala, Android und Webtechnologien bis hin zu agilen Entwicklungsmodellen und dem modernen, effizienten Betrieb von IT-Systemen (DevOps).

Der einzigartige Themenmix der Konferenzen verleiht Ihnen den entscheidenden Wissensvorsprung für laufende und zukünftige IT-Projekte. Die professionelle Organisation, hohe technische Kompetenz sowie das besondere Ambiente machen die W-JAX und die JAX zu einem einzigartigen Erlebnis, bei dem auch das Networking mit Kollegen und internationalen Experten nicht zu kurz kommt.

05. bis 9. November 2012

bis
RESTful HTTP - Beyond the Intro Level

There is probably no developer left who hasn't been exposed to at least one introduction to REST, and most have by now gathered some first-hand experience. In this session, there will be no introduction, only advanced stuff, such as hypermedia aspects, security, format/resource/representation design, and implementation issues - with room for lots of questions (and hopefully, answers).

Spezifizierst du noch oder implementierst du schon?

Wie viel Requirements Engineering braucht ein Produkt von der Analysephase bis in die Architektur? Wie viel ist bereits zu viel? Dieser Vortrag wird die entscheidenden Faktoren herausheben, die die laufenden Kosten in einem Projekt und die Methoden des Requirements Engineering wesentlich bestimmen, und wie Sie als Projektleiter das Ganze in eine konstruktive Richtung lenken.

Hitchhiker's Guide to the NetBeans Platform

Modulare Desktopanwendungen, API-Design, Nodes, Serviceinfrastrukturen, OSGi, deklarative Programmierung, Lazy Loading, Lifecycle Management... Keine Panik! Es ist eigentlich ganz einfach. In dieser Session bekommen Sie eine komplette Tour durch das NetBeans-Universum, und dabei wird auch noch die Towel-Locator-Desktopanwendung gebaut, damit Sie immer wissen, wo Ihr Handtuch ist.

Android Development Tools

Die Android Development Tools entwickeln sich schnell und sind nicht besonders gut dokumentiert oder bekannt. Dabei erleichtern sie den Arbeitsalltag ungemein und helfen das Verhalten der Plattform zu verstehen und Fehler zu finden. Wir schauen in dieser Session auf die Werkzeuge, zeigen anhand von Beispielen, wie man Fehler sucht und welche kleinen Helfer in den Tiefen der SDKs verborgen sind.

Smart Grids, Big Data and Java

Smart Grid systems represent the next evolution of the current energy infrastructure. The amount of data to be processed will increase exponentially as more and more smart devices get added to the grid. These smart devices will in turn generate all kinds of valuable data. Analyzing and processing this data in near-real time will be a challenge that will face many utility operators. This session will introduce Smart Grid concepts in general, and then talk about possible Java-based technologies that will address these challenges.

Keynote: Java and the Machine

In Terminator 3 - Rise of the Machines, bare metal comes back to haunt humanity, ruthlessly crushing all resistance. This keynote is here to warn you that the same thing is happening to Java and the JVM! Java was designed in a world where there were a wide range of hardware platforms to support. It's premise of Write Once Run Anywhere (WORA) proved to be one of the compelling reasons behind Java's dominance (even if the reality didn't quite meet the marketing hype). However, this WORA property means that Java and the JVM struggled to utilise specialist hardware and operating system features that could make a massive difference in the performance of your application. This problem has recently gotten much, much worse. Due to the rise of multi-core processors, massive increases in main memory and enhancements to other major hardware components (e.g. SSD) means that the JVM is now distant from utilising that hardware, causing some major performance and scalability issues! Kirk Pepperdine and Martijn Verburg will take you through the complexities of where Java meets the machine and loses. They'll give up some of their hard won insights on how to work around these issues so that you can plan to avoid termination, unlike some of the poor souls that ran into the T-800...

Android UI Patterns and Anti-Patterns 3

As in coding UI design has common solutions to common problems, design patterns. Finding right patterns can save a lot of time as well as make the app more appealing to the users. Common patterns bring consistency to the platform and make apps easier to learn. Then there are common mistakes, anti-patterns. Apps often seem to fall into similar traps trying to solve a problems. We can learn from mistakes of other to avoid them ourselves. Android UI patterns and anti-patterns are dos and do nots of Android app UI design.

Android UI Patterns and Anti-Patterns 1

As in coding UI design has common solutions to common problems, design patterns. Finding right patterns can save a lot of time as well as make the app more appealing to the users. Common patterns bring consistency to the platform and make apps easier to learn. Then there are common mistakes, anti-patterns. Apps often seem to fall into similar traps trying to solve a problems. We can learn from mistakes of other to avoid them ourselves. Android UI patterns and anti-patterns are dos and do nots of Android app UI design.

Android UI Patterns and Anti-Patterns 2

As in coding UI design has common solutions to common problems, design patterns. Finding right patterns can save a lot of time as well as make the app more appealing to the users. Common patterns bring consistency to the platform and make apps easier to learn. Then there are common mistakes, anti-patterns. Apps often seem to fall into similar traps trying to solve a problems. We can learn from mistakes of other to avoid them ourselves. Android UI patterns and anti-patterns are dos and do nots of Android app UI design.

Do your GC logs speaking to you 2

Getting GC logs is cheap and easy. Just set a couple of switches on the command line and you'll be given the insight into what this performance critical piece of the JVM is up to. For example, many applications are starved for memory in at least one of their internal memory pools. A simple check of the GC logs will tell you if your suffering from starvation. That same data can then be used to calculate a configuration that can result in huge differences in the performance of your application. But it's not only starvation that can be a problem. Having too much memory or an unbalanced configuration can be equally problematic. Or your problem may be as simple as your application's calling System.gc(). All these conditions can be, and in some cases, can only be, diagnosed by listening to what the logs are telling you. In this session we will look some interesting GC logs as well as tools that can be helpful in identifying anti-performance conditions.

Do your GC logs speaking to you 4

Getting GC logs is cheap and easy. Just set a couple of switches on the command line and you'll be given the insight into what this performance critical piece of the JVM is up to. For example, many applications are starved for memory in at least one of their internal memory pools. A simple check of the GC logs will tell you if your suffering from starvation. That same data can then be used to calculate a configuration that can result in huge differences in the performance of your application. But it's not only starvation that can be a problem. Having too much memory or an unbalanced configuration can be equally problematic. Or your problem may be as simple as your application's calling System.gc(). All these conditions can be, and in some cases, can only be, diagnosed by listening to what the logs are telling you. In this session we will look some interesting GC logs as well as tools that can be helpful in identifying anti-performance conditions.

Do your GC logs speaking to you 3

Getting GC logs is cheap and easy. Just set a couple of switches on the command line and you'll be given the insight into what this performance critical piece of the JVM is up to. For example, many applications are starved for memory in at least one of their internal memory pools. A simple check of the GC logs will tell you if your suffering from starvation. That same data can then be used to calculate a configuration that can result in huge differences in the performance of your application. But it's not only starvation that can be a problem. Having too much memory or an unbalanced configuration can be equally problematic. Or your problem may be as simple as your application's calling System.gc(). All these conditions can be, and in some cases, can only be, diagnosed by listening to what the logs are telling you. In this session we will look some interesting GC logs as well as tools that can be helpful in identifying anti-performance conditions.

Do your GC logs speaking to you 1

Getting GC logs is cheap and easy. Just set a couple of switches on the command line and you'll be given the insight into what this performance critical piece of the JVM is up to. For example, many applications are starved for memory in at least one of their internal memory pools. A simple check of the GC logs will tell you if your suffering from starvation. That same data can then be used to calculate a configuration that can result in huge differences in the performance of your application. But it's not only starvation that can be a problem. Having too much memory or an unbalanced configuration can be equally problematic. Or your problem may be as simple as your application's calling System.gc(). All these conditions can be, and in some cases, can only be, diagnosed by listening to what the logs are telling you. In this session we will look some interesting GC logs as well as tools that can be helpful in identifying anti-performance conditions.

Netty - Network Programming made easy

Netty ist ein Event-getriebenes Framework, das es erlaubt, schlanke und hochperformante Netzwerkapplikationen zu schreiben. Aufgrund seines Designs ist es somit eine echte Alternative zu anderen Frameworks oder gar der Verwendung eines Java-EE-Servers. Hinzu kommt, dass Netty mit seinem Unified API erlaubt, zwischen NIO (New-IO) und OIO (Old-IO) zu wechseln, ohne dass eine komplette Neuimplementation der Software notwendig ist. In diesem Vortrag werden die Features und die Funktionsweise von Netty anhand eines Beispiels beleuchtet.

Architecture and Collaboration: Cornerstones of Continuous Delivery Teil 1

Once you've been on a continuously-delivered project, there's no way back. The combination of rapid feedback, high levels of collaboration, and great software quality produces a virtuous delivery cycle that is both pleasing and effective. However, existing delivery models and product portfolios may not allow for straightforward adoption of CD. Technical and organisational debt accumulates inexorably over time and can make continuous delivery difficult or even impossible. In this session, we draw on our extensive project experience to demonstrate some of the software architecture patterns that enable continuous delivery. We look at related anti-patterns; and some strategies for getting a codebase into a shape such that it can be continuously delivered. We use examples of both successful and unsuccessful projects to show some of the rewards and pitfalls of following these strategies. As the structure of a software product changes, the organisation of the teams building and supporting it will need to go through concomitant changes. Using more real project examples, we discuss what drives these organisational changes, how they can be managed, and how to base a delivery team around collaboration rather than conflict. As we go, we engage members of the audience in a conversation about instances where they have seen similar issues, and encourage sharing of some methods that they might have tried. After this session, attendees will be able to recognise common anti-patterns in both software architecture and development practices. They will have an understanding of how these anti-patterns affect a development team's ability to deliver. Attendees will also have a number of tools and practices available to them to resolve those issues that are holding their team's continuous delivery efforts back.

Einführung NatTable

Adding tables or grids to an eclipse application is quite hard work if you want to support more than only showing information. With the usage of Nebula NatTable you are able to do this in an easier way, with significant less lines of code by getting a lot of grid functionality by simply using it. The session will show the main architecture of the NatTable widget and how easy it can be used and integrated into your own eclipse application, comparing it with other current table widgets out there. It will also give an overview of what is currently supported out of the box and what is planned for the NatTable in the future. After attending this talk you should understand what the difference between SWT tables and the NatTable is and how you can use the NatTable in your own eclipse application.

Power Workshop: Mobile JavaScript-Web-Apps professionell entwickeln Abschluss

Torsten Winterberg, Stefan Scheidt , Tobias Bosch

Java EE 7, Infinite Extensibility meets Infinite Reuse

An exploration of two bleeding edge concepts under active consideration in Java EE 7 to greatly expand annotation reuse across the platform and drastically improve the extensibility of the platform itself. The first part dives deep into the misunderstood MDB/Connector API, reveals the inner simplicity and shows that with a slight twist radical new APIs can be created for distributed communication with expressive APIs that can rival JAX-RS. The second half of this session explores the budding concept of annotation reuse that blossomed independently in three specifications of Java EE 6; Bean Validation, CDI, and JAX-RS. A fundamental change aims to allow all specifications to adopt annotation reuse and extend that ability to developers. An exciting glimpse into Java EE future, this session is a must for the bleeding edge enthusiast who loves to learn about the next big ideas before they hit the mainstream.

Power Workshop: Mobile JavaScript-Web-Apps professionell entwickeln Grundlagen

Torsten Winterberg, Stefan Scheidt , Tobias Bosch

Play Framework: Thou shalt not block (your Web App)

Developing scalable, responsive, non-blocking web applications has never been easier with the Play Framework 2.0, a modern framework for modern web applications. In this talk we will take a look at how Play can help us build the kind of dynamic and engaging web applications that user have come to expect, including pitfalls and challenges when developing them.

Vert.X

Vert.x is an event driven application framework that runs on the JVM - a run-time with real concurrency and unrivalled performance. Vert.x then exposes the API in Ruby, Java, Groovy and JavaScript, with more language implementations to come. This talk will be an introduction to the vert.x architecture, programming model, typical patterns and then a look at what's coming next in the framework and the component ecosystem developing around it.

Oscar-Renalias-Thou-shalt-not-block-your-web-app.pdf

In 2008, the PDF specification was published as an ISO standard: ISO-32000-1 (based on PDF 1.7). If all goes well, ISO-32000-2 (PDF 2.0!) will be released in 2013. One of the important changes involves digital signatures. PDF 2.0 will include the PAdES standard published by the European Telecommunications Standards Institute (ETSI). Furthermore some of the old types of digital signatures will be deprecated. In his talk, Bruno will guide you through the world of digital signing using a plethora of examples (including a demo on how to sign a document using the javax.smartcardio package). He'll focus on the best practices regarding signing, so that developers can make their applications future-proof.

Apache TomEE, Java EE 6 Web Profile on Tomcat

Apache TomEE is the Java EE 6 Web Profile certified version of Apache Tomcat and combines the simplicity of Tomcat with the power of Java EE. The first half of this session introduces TomEE and shows how Tomcat applications leveraging Java EE technologies can become simpler and lighter with a Java EE 6 certified solution built right on Tomcat. The second half focuses on those already familiar with TomEE and goes into detail on latest advancements, testing techniques including Arquillian, clustering features and production considerations. If you're a Tomcat lover or a TomEE enthusiast, this is the session you don't want to miss!

X
- Gib Deinen Standort ein -
- or -