Mon, 25 June 2007 OpenOffice.org is multi-platform, open source office productivity
suite. OOo natively uses the "OASIS Open Document Format for Office
Applications" while also fully supporting the Microsoft Office formats.
Due the fact of its standardized file format OOo becomes more and more
important in public offices and even enterprises. But even in more
complex environments an office suite needs to be integrated in existing
work flows, in existing applications or needs to be extended by some
special functionality to meet existing requirements. OpenOffice.org offers a language independent API which allows to program OpenOffic.org in Java, it allows to use OpenOffice.org as service provider in your own applications, extend it with new functionality or simply customize and control OpenOffice.org. This session will give a general overview of the OOo programmability capabilities including tool support. Comments[0] |
Mon, 25 June 2007 AJAX Development with JavaServer Faces: Look Ma, No JavaScript! This session explains how you can build attractive, AJAX-enabled applications using JavaServer Faces (JSF) technology without the use of manually-coded JavaScript. After a brief overview of JSF and the JSF programming model, the session explains how component vendors leverage JSF's architecture to build AJAX components, and shows several of AJAX component suites in action. The session ends with a discussion of how JSF will evolve to provide even better AJAX support. This session is pretty different from Roger Kitian's JSF session, but if you guys feel like there is too much overlap, here are some other possibilities: Architecting JavaServer Faces Applications Over the past year, a lot of time has been spent explaining what JSF is, and how different pieces of it work. However, little attention has been given to the process of architecting applications. This makes JSF architecture seem like a black art, since there are so many possible approaches to the application's architecture. Intro to JavaServer Faces JavaServer Faces (JSF) is a standard web user interface framework, developed under the Java Community Process (JSR 127), and released in March, 2004. JSF specifies a web user interface component model, complete with server-side event handling, validation, internationalization, page navigation, and declarative mapping between user interface components and Java objects. Exploring the JavaServer Faces Ecosystem This session examines the ecosystem that is growing around JavaServer Faces. Comments[0] |
Mon, 25 June 2007 Large scale enterprise application deployments face challenges in development and deployment. Java EE 5 provides a mature and robust API for authoring enterprise applications. This talk tackles the issues with deploying such enterprise applications in the "real world". Specifically we'll discuss the advances in packaging reusable applications, disruption-free application upgrades and application lifecycle management. We will explore some of the ways that the Java EE 5 specification and BEA's WebLogic Server address these issues. Direct download: JavaPolis_-_06_Java_EE_Enhancements_for_Real_World_depolyments.mp3 Category: podcasts -- posted at: 2:52 AM Comments[0] |
Sat, 16 June 2007 The Eclipse Rich Client Platform provides a feature rich framework for the development of rich client applications. This talk presents tips and tricks for the development of such applications. Kai introduces some general development tricks that are helpful for all users of the Eclipse SDK. E.g. the usage of extension locations in combination with links, conditional breakpoints, and some logging tips. XML contributions vs. code Package and Plug-in Structures Deployment & Update Issues when using 3rd Party Libraries Comments[0] |
Tue, 12 June 2007 The technique of domain logical value-objects (DLVO) is a method for domain-driven programming that stays close to the code. It takes the "middle road" by identifying domain concepts that are more than "just data" (e g strings and integers), but still not "big enough" to qualify as long lived objects with a unique identity (e g customers and orders). Examples from a CRM application could include phone numbers, credit classifications, email addreses, and contact intervals. By explicitly spelling these out in the design, they provide an effective way of gathering validation and other operations for reuse. As an effect it simplifies a lot of other code, which was earlier luttered with these kinds of operations. The major advantage of using DLVOs is that it can start being applied immediately. It does neither take structural changes of the overall structure, nor craves a heavy round of preparing refactorings. So, it can be applied with a very small initial effort. In that way, it is possible to very fast start reaping some of the fruits of the domain driven approach, e g more structured in-data validation, more expressive service-APIs and clearer code in the business logic (often EJBs or similar). I this session we present domain-logical value objects, and how you write and use them in practice. The concrete code examples are in Java, but the ideas and techniques can just as well be applied to code written in C++/C, VB or Ruby. Direct download: JavaPolis_-_06_Get_Value_Objects_right_for_Domain_Driven_Design_.mp3 Category: podcasts -- posted at: 1:18 PM Comments[0] |
Tue, 12 June 2007 Spring 2.0 introduced major enhancements in the Spring Framework making it both simpler to use and more powerful. In this session, Rod discusses some of the enhancements through code examples, focusing on: - Extensible XML configuration, support for dynamic languages in the Spring component model, and support for JPA. Rod demonstrates how Spring 2.0 provides a launching pad for further developments in 2007, discussing the implications of OSGi integration for the Spring component model, and additional configuration options. Finally Rod surveys the Spring Portfolio, and show how the ecosystem around Spring helps in many areas of enterprise development. Comments[0] |
Wed, 6 June 2007 The power of Eclipse is a direct result of its capability to embrace new technologies. Here we present a unique approach to embrace Swing, which might determine the future of Eclipse on all levels, such as Client, Embedded, RCP and RIA. Wouldn't it be great, if one had the choice between SWT and Swing not only at the beginning of a project but throughout development? How about using the familiar APIs to develop Eclipse-Plug-ins, RCP-applications or a JFace/SWT-GUI and still keep the option to switch back and forth between SWT and Swing without changes to your code? The sister projects SWTSwing and Eclipse on Swing (EOS) by Christopher Deckers and Dieter Krachtus offer this solution. The prerequisites needed to understand and successfully use this technology are minimal since the EOS-Project offers a plug-in that hooks into the preferences of Eclipse or any RCP-based application and allows switching between SWT and Swing. Since it is easy to understand how, it is more important to understand when, where, and why to use this new technology. We both explain the technical details and advantages a Swing implementation of SWT offers already today. Unlike most parts of Eclipse, SWT is a unique and irreplaceable element right at the root of Eclipse. Therefore, we also focus on the motivations behind the EOS project, which is not only about offering a whole new set of possibilities, but also about flexibility and security considering the future of Eclipse. At last we demonstrate the quality of our solution by running popular applications like Azureus, Bioclipse and even Eclipse itself on Swing. Comments[0] |
Mon, 4 June 2007 Java allows the experienced developer to write highly flexible code, especially when using dynamic features like proxies and references. In this talk, Heinz brings these together with generics and enums. He will demonstrate some approaches of using Java's dynamic proxies to create virtual proxies, protection proxies, dynamic object adapters and dynamic decorators. A part of the talk will also explore the performance implications and compare it with the benefits gained. P.S. If you are wondering why "enum" is listed under "advanced features" you should definitely attend this talk. Direct download: JavaPolis_-_06_Java_Specialist_in_Action.mp3 Category: podcasts -- posted at: 2:27 AM Comments[2] |
Thu, 31 May 2007 Your high performance application is facing continuous and exponential growth in transaction and data volume? You know that SOA is the right architecture for addressing these challenges, but at the same time, you understand that web services cannot be the right way to go, because of their inherent performance limitation? This session will show you how POJO services, combined with a Space Based Architecture approach, will help you build stateful SOA in a high performance environment. More than that: you will see how Spring can turn your POJO into a highly efficient service that can dynamically scale across an entire network of machines without changing your code. Comments[0] |
Thu, 31 May 2007 Number Portability is something that Telecom Operators need to
implement by law. This case is about how automating this process can
deliver a return on investment for the Telecom Operator, and how
professional open source can support this. The presentation will make
use of an existing case that JCS/Dolmen implemented at there customer
and how JBoss products like AS and jBPM were used to realize the Number
Portability issue. Direct download: JavaPolis_-_06_Number_Portability__SIP_and_Open_Source__Software.mp3 Category: podcasts -- posted at: 11:38 AM Comments[0] |
