Posts Tagged ‘DevoxxBE2012’
[DevoxxBE2012] Weld-OSGi in Action
Mathieu Ancelin and Matthieu Clochard, software engineers at SERLI specializing in Java EE and modular systems, showcased the synergy between CDI, OSGi, and Weld in their Weld-OSGi framework during DevoxxBE2012. Mathieu, a member of the CDI 1.1 expert group and contributor to projects like GlassFish, collaborated with Matthieu, who focuses on OSGi integrations, to demonstrate how Weld-OSGi simplifies dynamic application assembly without added complexity.
They started with CDI basics, where dependency injection manages component lifecycles via annotations like @Inject. OSGi’s modularity, with bundles as deployment units and a dynamic service registry, complements this by allowing runtime changes. Weld-OSGi bridges them, enabling CDI beans to interact seamlessly with OSGi services.
A demo illustrated bootstrapping Weld-OSGi in an OSGi environment, registering bundles, and using extensions for event handling. They emphasized transparent service interactions, where CDI observes OSGi events for dynamic updates.
Mathieu and Matthieu highlighted Weld-OSGi’s role in making OSGi accessible, countering perceptions of its difficulty by leveraging CDI’s programming model.
Fundamentals of CDI and OSGi Integration
Mathieu explained CDI’s bean management, scopes, and qualifiers for precise injections. Matthieu detailed OSGi’s bundle lifecycle and service registry, where services publish and consume dynamically.
Weld-OSGi embeds CDI containers in OSGi, using extensions to observe bundle events and register services as beans. This allows injecting OSGi services into CDI components effortlessly.
Dynamic Features and Practical Demonstrations
They demonstrated service dynamism: publishing a service updates dependent beans automatically. Unpublishing triggers alternatives or errors, ensuring robustness.
Demos included hybrid applications where Java EE components interact with OSGi bundles via the registry, deploying parts dynamically without restarts.
Future Prospects and Community Engagement
Mathieu discussed ongoing work for hybrid servers like GlassFish, embedding Weld-OSGi for cleaner integrations. They referenced RFC 146, inspired by Weld-OSGi, for native CDI-OSGi support.
Encouraging trials, they pointed to GitHub repositories with examples and documentation, fostering feedback to evolve the framework.
Mathieu and Matthieu’s presentation illustrated Weld-OSGi’s potential to create fully dynamic modular applications, blending CDI’s elegance with OSGi’s power.
Links:
[DevoxxBE2012] The Chrome Dev Tools Can Do THAT
Ilya Grigorik, a Google web performance engineer and developer advocate, unveiled advanced capabilities of Chrome Developer Tools. Ilya, focused on accelerating the web, overwhelmed attendees with tips, dividing into inspection/debugging and performance analysis.
He encouraged hands-on exploration via online slides, emphasizing tools’ instrumentation for pinpointing bottlenecks.
Starting with basics, Ilya showed inspecting elements, modifying DOM/CSS live, and using console for JavaScript evaluation.
Advanced features included remote debugging for mobile, connecting devices to desktops for inspection.
Inspection and Debugging Essentials
Ilya demonstrated breakpoints on DOM changes, XHR requests, and events, pausing execution for analysis.
Color pickers, shadow DOM inspection, and computed styles aid UI debugging.
Console utilities like $0 for selected elements, querySelector, and table formatting enhance interactivity.
JavaScript Profiling and Optimization
CPU profilers capture call stacks, revealing hot spots. Ilya profiled loops, identifying inefficiencies.
Heap snapshots detect memory leaks by comparing allocations.
Source maps map minified code to originals, with pretty-printing for readability.
Network and Resource Analysis
Network panel details requests, with filters and timelines. Ilya explained columns like status, size, showing compression benefits.
WebSocket and SPDY inspectors provide low-level insights.
HAR exports enable sharing traces.
Timeline and Rendering Insights
Timeline records events, offering frame-by-frame analysis of layouts, paints.
Ilya used it to optimize animations, enabling GPU acceleration.
CSS selectors profile identifies slow rules.
Auditing and Best Practices
Audits suggest optimizations like minification, unused CSS removal.
Extensions customize tools further.
Low-Level Tracing and Customization
Chrome Tracing visualizes browser internals, instrumentable with console.time for custom metrics.
Ilya’s session equipped developers with powerful diagnostics for performant, debuggable applications.
Links:
[DevoxxBE2012] Raise Your Java EE 6 Productivity Bar with JBoss Forge
Koen Aers, a Red Hat engineer driving Eclipse integration for JBoss Forge, alongside guest Ivan St. Ivanov from SAP, explored boosting Java EE 6 development efficiency. Koen, with a background in jBPM and workflow editors, refreshed on Forge’s role in simplifying complex setups for novices.
Forge, a command-line tool using CDI, incrementally adds features to projects. Commands scaffold entities, UI, and services swiftly.
They demonstrated creating a project, adding persistence with JPA, generating entities like Speaker and Session, and scaffolding JSF views.
For tasks beyond built-ins, plugins extend functionality. Ivan showed developing an Envers plugin for auditing, installing it, and applying to entities.
Integration with IDEs like Eclipse opens Forge’s power graphically.
Their demo built a conference app, adding history views with auditing, showcasing rapid enhancements.
Koen and Ivan emphasized Forge’s elevation of productivity, enabling faster iterations.
Introducing Forge and Basic Workflows
Koen explained Forge’s shell for navigating projects, setting up Maven builds, and adding facets like JPA for persistence.xml configuration.
Commands generate entities with fields, relationships via annotations.
Scaffolding and UI Generation
Scaffolding creates CRUD operations and JSF views from entities, deploying to servers like AS7.
They customized views, adding fields and relations.
Extending with Plugins
Ivan illustrated plugin creation: facets detect capabilities, commands execute actions like adding dependencies.
The Envers plugin audited entities, integrating seamlessly.
IDE Integration and Real-World Application
Eclipse plugins embed Forge consoles, enhancing workflows.
In demo, they audited entities, added history beans, and viewed changes, proving incremental power.
Koen and Ivan’s insights highlighted Forge’s transformative impact on Java EE development.
Links:
[DevoxxBE2012] Rapid Application Development with Play 2
Peter Hausel, a core team member of the Play Framework and software engineer at Typesafe, demonstrated the efficiencies of Play 2 for swift web development in both Java and Scala. With a background in web technologies and open source, Peter showcased how Play streamlines workflows, emphasizing live coding to illustrate its features.
He initiated by creating a new Java-based application, highlighting Play’s MVC structure: controllers for logic, views for Scala-based templates, and routes for URL mapping. Peter noted that even Java projects use Scala templates, which require minimal learning akin to JSP.
A key advantage is on-the-fly compilation; changes reload automatically without restarts, accelerating iterations. Peter modified a controller and template, refreshing the browser to see instant updates.
Type-safe templates and routes prevent runtime errors, with compile-time checks ensuring correctness. He integrated front-end tools like CoffeeScript, LESS, and Google Closure Compiler, compiling them seamlessly into production assets.
Peter explored asset management, using RequireJS for modular JavaScript, and reverse routing to generate URLs dynamically, avoiding hardcoding.
For production, he packaged the app into a distributable ZIP, running it standalone. He peeked into running applications via REPL for interactive debugging.
Testing was touched upon, with future scaffolding promised to generate tests easily.
Peter’s demo underscored Play’s design for productivity, blending familiarity with powerful abstractions.
Core Structure and Development Workflow
Peter detailed Play’s layout: app folder houses controllers, views, and assets; conf holds configurations and routes. Routes define HTTP methods, paths, and controllers, supporting parameters for dynamic handling.
In live coding, he added a new route and controller method, demonstrating error handling where compilation failures display directly in the browser, guiding fixes.
Templates use Scala syntax for logic, with type safety catching mismatches early. Peter included layouts via @main, composing reusable structures.
Front-End Integration and Asset Handling
Play compiles CoffeeScript and LESS on-the-fly, minifying with Closure for optimization. Peter added a CoffeeScript file, seeing it transform into JavaScript.
RequireJS integration modularizes scripts, with routes serving them efficiently.
Deployment and Advanced Features
Packaging creates self-contained distributions, runnable via commands. REPL allows inspecting live state.
Peter recapped: routes centralize mapping, auto-reload speeds development, and reverse routing enhances maintainability.
His session positioned Play as a tool for rapid, robust applications.
Links:
[DevoxxBE2012] The Advantage of Using REST APIs in Portal Platforms to Extend the Reach of the Portal
Rinaldo Bonazzo, a seasoned IT professional with extensive experience in project management and technology evangelism for Entando, highlighted the strategic benefits of integrating REST APIs into portal platforms during his presentation. Rinaldo, who has led initiatives in sectors like animal health and European community projects, emphasized how Entando, an open-source Java-based portal, leverages REST to facilitate seamless data exchange across diverse systems and devices.
He began by outlining Entando’s capabilities as a comprehensive web content management system and framework, enabling developers to build vertical applications efficiently. Rinaldo explained the decision to adopt JSR-311 (now part of Java EE 6) for RESTful services, which allows Entando to connect with external clients effortlessly. This approach minimizes development effort, as REST standardizes interactions using lightweight protocols like JSON or XML, making integration with web clients, smartphones, and tablets straightforward.
In a practical demonstration, Rinaldo showcased creating a service to publish open data across multiple devices. He illustrated how REST APIs provide a base URI for accessing resources, such as content, images, or entities, without the overhead of more complex protocols. This not only accelerates development but also ensures that portals can reach beyond traditional boundaries, fostering broader adoption within organizations.
Rinaldo stressed the importance of REST in modern architectures, where portals must interact with sensors, mobile apps, third-party services like BI tools or CRM systems, and even legacy applications. By collecting data from various sources—such as IoT devices in smart cities or user inputs from mobile forms—Entando exposes this information uniformly, supporting web browsers, extranets, and accessibility features for users with disabilities.
He shared real-world examples from Entando’s deployments, including portals for the Italian Civil Defense Department and the Ministry of Justice. These implementations prioritize accessibility, ensuring compliance with standards that allow visually impaired users to access content. Rinaldo pointed to the municipality of Cerea’s open data initiative, where REST APIs enable developers to retrieve resources like georeferenced data or submit requests via mobile apps, demonstrating practical extensions of portal functionality.
Furthermore, Rinaldo discussed security aspects, noting Entando’s use of OAuth for authorization, which secures API access with tokens. This ensures safe data exchange while maintaining openness.
Overall, Rinaldo’s insights underscored how REST APIs transform portals from isolated systems into interconnected hubs, enhancing reach and utility. By adhering to established standards, developers can innovate rapidly, integrating portals with emerging technologies and meeting diverse user needs effectively.
Extending Portal Functionality Through Integration
Rinaldo elaborated on the architectural advantages, where REST enables portals to act as central data aggregators. For instance, in smart city applications, APIs collect sensor data for traffic management, which portals then process and disseminate. Similarly, mobile integrations allow direct content insertion, as seen in Maxability’s iPhone app for Entando, where users submit georeferenced photos that portals geolocate and manage.
He highlighted government successes in Italy, where Entando’s portals support critical operations while ensuring inclusivity. Features like API documentation pages, as in Cerea’s developer portal, provide clear guidance on endpoints, methods, and parameters, lowering barriers for external developers.
Rinaldo concluded by inviting engagement with Entando’s community, reinforcing that REST not only extends reach but also promotes collaborative ecosystems. His presentation illustrated a shift towards open, extensible platforms that adapt to evolving digital landscapes.
Links:
[DevoxxBE2012] 7 Things: How to Make Good Teams Great
Sven Peters, an Atlassian ambassador with over a decade in Java EE development and team leadership, shared strategies for elevating competent teams to exceptional levels. Sven, passionate about clean code and developer motivation, drew from Atlassian’s experiences to outline seven practices fostering innovation and productivity while sustaining focus on quality products.
He opened by challenging assumptions about agile methodologies, observing that some self-proclaimed agile teams underperform, while certain traditional ones excel. Sven emphasized that true greatness transcends labels, requiring deliberate actions to boost morale and efficiency.
Atlassian, known for tools like Jira and Confluence, exemplifies these principles through an open culture that values feedback and experimentation. Sven warned that while inspiring, these methods must adapt to individual contexts, with readiness to iterate based on outcomes.
Enhancing Focus and Flow
Sven advocated protecting developers’ concentration, introducing “do not disturb” periods where interruptions halt, allowing deep work. At Atlassian, engineers signal availability with signs, reducing context switches that hinder productivity.
He stressed feeding intellectual curiosity via learning opportunities, such as internal talks or external conferences. These sessions, often during lunch, cover diverse topics, sparking ideas and cross-team collaboration.
Appreciating efforts, even minor ones, builds positivity. Sven described Atlassian’s kudos system, where peers publicly recognize contributions, reinforcing a supportive environment.
Automating Insights and User Empathy
To streamline oversight, Sven recommended automated reports aggregating metrics like code commits and bug fixes. These dashboards provide quick overviews without manual effort, freeing time for creative tasks.
“Dogfooding”—using one’s own products internally—bridges gaps between creators and users. At Atlassian, this uncovers issues early, fostering empathy and better designs. Sven shared how it led to improvements in their tools.
Sparking Innovation Through Dedicated Time
Special days, like “ShipIt” events, tackle backlog items in focused bursts. Atlassian’s 24-hour hackathons encourage wild ideas, with voting and implementation for winners, injecting fun and progress.
Experimentation time, such as 20% personal projects, drives breakthroughs. Sven recounted how this birthed features like Jira’s rapid boards, enhancing products while empowering staff.
He rated these practices’ feasibility and impact, urging measured trials to gauge effectiveness.
Adapting and Measuring Success
Sven concluded by encouraging experimentation, acknowledging failures as learning opportunities. Atlassian’s disbanded innovation team taught that distributed creativity works better.
He advised time-boxing initiatives, tracking results, and customizing approaches. Being distinctive in practices attracts and retains talent in a competitive field.
Sven’s insights, rooted in real-world application, offer a blueprint for transforming solid teams into outstanding ones through intentional, adaptive strategies.
Links:
[DevoxxBE2012] Putting Kotlin to the Test
During DevoxxBE2012, Hadi Hariri, a developer and technical evangelist at JetBrains, presented an in-depth evaluation of Kotlin, a then-emerging programming language designed by his company. Hadi, with his background in software architecture and web development, aimed to assess whether Kotlin could address common pitfalls in existing languages while serving as a versatile tool for various development needs. He began by providing context on Kotlin’s origins, noting its static typing, object-oriented nature, and targets for JVM bytecode and JavaScript compilation. Licensed under Apache 2.0, it was at milestone M3, with expectations for further releases leading to beta.
Hadi explained the motivation behind Kotlin: after years of building IDEs in Java, JetBrains sought a more efficient alternative without the complexities of languages like Scala. He highlighted Kotlin’s focus on practicality, aiming to reduce boilerplate and enhance productivity. Through live coding, Hadi demonstrated building a real-world application, showcasing how Kotlin simplifies syntax and integrates seamlessly with Java.
One key aspect was Kotlin’s concise class definitions, where properties and constructors merge into a single line, eliminating redundant getters and setters. Hadi illustrated this with examples, contrasting it with verbose Java equivalents. He also touched on null safety, where the language enforces checks to prevent null pointer exceptions, a frequent issue in other systems.
As the session progressed, Hadi explored functional programming elements, such as higher-order functions and lambdas, which allow for expressive code without excessive ceremony. He built components of an application, like data models and services, to test interoperability and performance.
Syntax Innovations and Productivity Gains
Hadi delved into Kotlin’s syntax, emphasizing features like extension functions that add methods to existing classes without inheritance. This promotes cleaner code and reusability. He showed how to extend standard library classes, making operations more intuitive.
Data classes were another highlight, automatically providing equals, hashCode, and toString methods, ideal for immutable objects. Hadi used these in his demo app to handle entities efficiently.
Pattern matching via ‘when’ expressions offered a more powerful alternative to switch statements, supporting complex conditions. Hadi integrated this into control flows, demonstrating reduced branching logic.
Smart casts automatically handle type checks, minimizing explicit casts. In his application, this streamlined interactions with mixed-type collections.
Interoperability and Platform Targets
A core strength, as Hadi pointed out, is Kotlin’s full compatibility with Java. Code can call Java libraries directly, and vice versa, facilitating gradual adoption. He compiled mixed projects, showing no performance overhead.
Targeting JavaScript, Kotlin compiles to efficient code for web fronts, sharing logic between server and client. Hadi previewed this, noting potential for unified development stacks.
He addressed modules and versioning, still in progress, but promising better organization than Java packages.
Functional and Advanced Constructs
Hadi introduced traits, similar to interfaces but with implementations, enabling mixin-like behavior. He used them to compose behaviors in his app.
Delegated properties handled lazy initialization and observables, useful for UI bindings or caching.
Coroutines, though nascent, hinted at simplified asynchronous programming.
In Q&A, Hadi clarified comparisons to Ceylon and Scala, noting Kotlin’s balance of comprehensibility and power. He discussed potential .NET targeting, driven by demand.
Real-World Application Demo
Throughout, Hadi built a sample app, testing features in context. He covered error handling, collections, and concurrency, proving Kotlin’s robustness.
He encouraged trying Kotlin via IntelliJ’s community edition, which supports it natively.
Hadi’s presentation positioned Kotlin as a promising contender, fixing expensive language flaws while maintaining industrial applicability.
Links:
[DevoxxBE2012] First Steps with Scala (Part 1/2)
In an engaging session, Dick Wall and Bill Venners, co-founders of Escalate Software and prominent figures in the Scala community, introduced newcomers to the Scala programming language. Dick, known for his JavaPosse involvement, and Bill, president of Artima and author of key Java texts, adapted their training curriculum to cover foundational elements. Their approach fused object-oriented and functional paradigms, emphasizing Scala’s blend of familiarity and innovation.
They commenced with the Scala REPL, a tool they use daily for experimentation. This interactive shell allows immediate code execution, inferring types and storing results for reuse, making it invaluable even for Java developers exploring libraries.
Dick and Holly—wait, Dick and Bill—highlighted Scala’s strong typing with inference, reducing boilerplate while maintaining safety. They demonstrated basic operations, showing how everything integrates into a unified hierarchy, unlike Java’s primitives and references.
Defining Variables and Immutability
Transitioning to variables, Dick and Bill distinguished between vals (immutable) and vars (mutable), promoting vals for reliability. This design choice encourages constant use without extra syntax, contrasting Java’s final keyword. They illustrated reassignment errors, noting REPL’s scoping allows redefinitions, mimicking nested blocks.
Type specifications, optional due to inference, follow names with colons, inverting Java’s order for natural flow. Examples showed string inferences and explicit declarations, underscoring flexibility.
They addressed mutability choices, advising private volatile vars for necessary changes, or mutable objects within immutable structures, depending on context.
Control Structures and Expressions
Dick and Bill explored control structures, revealing Scala’s expression-oriented nature. If statements return values, enabling concise assignments without ternaries. While loops, though imperative, yield Unit, encouraging functional alternatives.
For comprehensions, powerful for iteration, support guards and yields, transforming collections declaratively. They demonstrated filtering even numbers or yielding transformed lists, highlighting pattern matching integration.
Try-catch blocks, also expressions, handle exceptions functionally, with finally clauses for cleanup. This uniformity simplifies code, treating controls as value producers.
Functions and Closures
Delving into functions, they defined them as objects, enabling higher-order usage. Simple defs showed parameter typing and inference, with return types often omitted.
Function literals, akin to lambdas, capture environments as closures, allowing deferred execution. Examples illustrated anonymous functions for mapping or filtering, emphasizing Scala’s functional leanings.
They introduced by-name parameters for lazy evaluation, useful in custom controls like loops, mimicking built-in syntax without special privileges.
Collections and Functional Programming
Scala collections, immutable by default, support transformations via methods like map and filter. Dick and Bill showcased creating lists, accessing elements, and applying operations, yielding new collections without mutation.
They contrasted mutable variants, advising caution for concurrency. For comprehensions over collections generate new ones, combining iteration with functional purity.
Approaching functional style, they encouraged avoiding side effects, using recursion or folds for aggregations, fostering predictable code.
Advanced Basics and Q&A Insights
In Q&A, they addressed optimizations: Scala uses primitives internally, with @specialized for generics avoiding boxing. Profiling mirrors Java tools, with quirks in coverage.
Dick and Bill wrapped by previewing afternoon labs on Scala Koans, urging practice. Their session laid a solid groundwork, blending theory with practical demos, preparing attendees for Scala’s expressive power.
Links:
[DevoxxBE2012] Building Modular Applications with Enterprise OSGi
At DevoxxBE2012, Tim Ward and Holly Cummins, both seasoned experts in OSGi and enterprise technologies, delivered a comprehensive exploration into leveraging Enterprise OSGi for constructing modular applications. Tim, affiliated with Paremus and a key contributor to Apache Aries, alongside Holly from IBM, who focuses on WebSphere and performance tooling, guided attendees through the intricacies of transforming traditional Java EE setups into dynamic, OSGi-based systems. Their session bridged familiar concepts like WAR files and dependency injection with OSGi’s modularity, addressing common pain points in class path management.
They initiated the discussion by outlining Enterprise OSGi’s origins and relevance. Emerging in 2010, this specification enhances OSGi’s core, which has powered embedded systems and IDEs like Eclipse for over a decade, to better suit server-side enterprise needs. Tim and Holly emphasized how it integrates seamlessly with application servers, enabling features such as web applications, database interactions, and transaction management within an OSGi framework.
A key theme was the modularity crisis in large Java EE projects. They illustrated how sprawling WAR files, often exceeding server sizes like Tomcat’s 7MB core, accumulate unnecessary libraries, leading to class path hell. By contrasting tangled dependency graphs with OSGi’s structured approach, they demonstrated how explicit module definitions simplify maintenance and foster cleaner architectures.
Embracing OSGi Modularity Basics
Delving deeper, Tim and Holly explained OSGi’s bundle model, where each bundle—a JAR with added metadata—declares imports and exports via manifests. This enforces visibility rules, preventing accidental dependencies and promoting intentional design. They highlighted how bundles resolve dynamically, allowing runtime adaptability without redeployments.
The duo addressed common misconceptions, asserting that OSGi simplifies both complex and straightforward tasks. For instance, they showcased how dependency injection via Blueprint or Spring works effortlessly in OSGi, maintaining developer familiarity while adding modularity benefits.
They also touched on third-party library integration, noting challenges with non-OSGi JARs but solutions through tools that convert them into bundles. This ensures compatibility, reducing the bloat from redundant inclusions like JavaMail APIs.
Transitioning from WAR to WAB
A pivotal segment focused on evolving WAR files into Web Application Bundles (WABs). Tim and Holly demonstrated this migration, starting with a standard WAR and incorporating OSGi manifests to define it as a bundle. This shift enables deployment in OSGi containers like Apache Karaf or WebSphere Liberty, preserving servlet functionality while gaining modularity.
They illustrated error handling advantages: OSGi fails fast on missing dependencies, unlike runtime surprises in traditional setups. Through live examples, they showed bundles starting only when requirements are met, enhancing reliability.
Furthermore, they explored dynamism, where services can be added or removed at runtime, updating applications without downtime. This transparency in remoting and service interactions aligns with Java EE goals but executes more fluidly in OSGi.
Handling Dependencies and Repositories
Tim and Holly then examined dependency management, advocating explicit declarations to avoid hidden assumptions. They introduced bundle repositories, akin to Maven but tailored for OSGi, which automatically provision required bundles. This centralizes library control, aiding compliance in regulated environments.
In demonstrations, they deployed applications across servers like Liberty and Karaf, resolving dependencies on-the-fly. For instance, adding Joda Time via a repository revived a stalled bundle, showcasing practical modularity.
They stressed architectural enforcement: OSGi’s rules prevent poor practices, but good design remains essential. Tools like Eclipse plugins aid in visualizing and managing these structures.
Demonstrating Dynamism and Best Practices
The session culminated in hands-on demos, where a simple web app evolved into a dynamic OSGi system. Starting with a basic servlet, they integrated services for runtime changes, like toggling UI elements without restarts.
Tim and Holly concluded by reinforcing OSGi’s power in enforcing scalable, maintainable systems. They recommended resources, including their book “Enterprise OSGi in Action,” for further learning. Their presentation underscored how Enterprise OSGi not only resolves class path issues but elevates enterprise development to new levels of flexibility and efficiency.
Links:
[DevoxxBE2012] Apache TomEE: Java EE 6 Web Profile on Tomcat
David Blevins, a veteran in open-source Java EE and founder of projects like OpenEJB and TomEE, showcased Apache TomEE. With over a decade in specifications like EJB and CDI, David positioned TomEE as a bridge for Tomcat users seeking Java EE capabilities.
He polled the audience, revealing widespread Tomcat use alongside other servers, highlighting the migration pain TomEE addresses. David described TomEE as Tomcat enhanced with Java EE, unzipping Tomcat, adding Apache projects like OpenJPA and CXF, then certifying the bundle.
Emphasizing small size, certification, and Tomcat fidelity, David outlined distributions: Web Profile (minimal specs), JAX-RS (adding REST), and Plus (including JMS, JAX-WS).
Understanding the Web Profile
David clarified the Java EE 6 Web Profile, a subset of 12 specs from the full 24, excluding outdated ones like CORBA and CMP. This acknowledges Java EE’s growth, focusing on essentials for modern apps.
He noted exclusions like JAX-RS (added in EE 7) and inclusions like JavaMail in TomEE’s Web Profile for practicality. David projected EE 7’s profile reductions, potentially enabling full-profile TomEE certification.
Demonstrating TomEE in Action
In a live demo, David set up TomEE in Eclipse using Tomcat adapters, creating a servlet with EJB injection and JPA. He deployed seamlessly, showcasing CDI, transactions, and web services, all within Tomcat’s familiar environment.
David highlighted TomEE’s lightweight footprint—under 30MB—booting quickly with low memory. He integrated tools like Arquillian for testing, demonstrating in-container and embedded modes.
Advanced Features and Configuration
David explored clustering with Hazelcast, enabling session replication without code changes. He discussed production readiness, citing users like OpenShift and Jelastic.
Configuration innovations include flat XML-properties hybrids, human-readable times (e.g., “2 minutes”), and dynamic resource creation. David showed overriding via command-line or properties, extending for custom objects injectable via @Resource.
Error handling stands out: TomEE collects all deployment issues before failing, providing detailed, multi-level feedback to accelerate fixes.
Community and Future Directions
Celebrating TomEE’s first year, David shared growth metrics—surging commits and mailing lists—inviting contributions. He mentioned production adopters praising its simplicity and performance.
David announced a logo contest, encouraging participation. In Q&A, he affirmed production use, low memory needs, and solid components like OpenJPA.
Overall, David’s talk positioned TomEE as an empowering evolution for Tomcat loyalists, blending familiarity with Java EE power.