Posts Tagged ‘RedHat’
[DevoxxUS2017] Eclipse Che by Tyler Jewell
At DevoxxUS2017, Tyler Jewell, CEO of Codenvy and project lead for Eclipse Che, delivered a compelling session on the shift from localhost to cloud-based development. Highlighting Eclipse Che as a next-generation IDE and workspace server, Tyler discussed how it streamlines team collaboration and agile workflows. With contributions from industry leaders like Red Hat and Microsoft, Che has rapidly gained traction. This post explores the key themes of Tyler’s presentation, focusing on the future of cloud development.
The Rise of Cloud Development
Tyler Jewell began by outlining market forces driving the adoption of cloud development, such as the need for rapid onboarding and consistent environments. He contrasted traditional localhost setups with cloud-based workflows, emphasizing how Eclipse Che enables one-click environment creation. Tyler’s insights, drawn from his role at Codenvy, highlighted Che’s ability to reduce setup time, allowing teams to focus on coding rather than configuration.
Eclipse Che’s Workspace Innovation
Delving into technical details, Tyler showcased Che’s workspace server, which supports reproducible environments through containerized runtimes. Unlike Vagrant VMs, Che workspaces offer lightweight, scalable solutions, integrating seamlessly with Docker. He demonstrated how Che’s architecture supports distributed teams, enabling collaboration across geographies. Tyler’s live demo illustrated creating and managing workspaces, underscoring Che’s role in modernizing development pipelines.
Community Contributions and Roadmap
Tyler emphasized the vibrant Eclipse Che community, with nearly 100 contributors from companies like IBM and Samsung. He discussed ongoing efforts to enhance language server integration, citing the Language Server Protocol’s potential for dynamic tool installation. Tyler shared Che’s roadmap, focusing on distributed workspaces and team-centric features, inviting developers to contribute to its open-source ecosystem.
Balancing IT Control and Developer Freedom
Concluding, Tyler addressed the tension between IT control and developer autonomy, noting how Che balances root access with governance. He highlighted its integration with agile methodologies, enabling faster iterations and improved collaboration. Tyler’s vision for Che, rooted in his experience at Toba Capital, positioned it as a transformative platform for cloud-native development, encouraging attendees to explore its capabilities.
Links:
[DevoxxUS2017] The Hardest Part of Microservices: Your Data by Christian Posta
At DevoxxUS2017, Christian Posta, a Principal Middleware Specialist at Red Hat, delivered an insightful presentation on the complexities of managing data in microservices architectures. Drawing from his extensive experience with distributed systems and open-source projects like Apache Kafka and Apache Camel, Christian explored how Domain-Driven Design (DDD) helps address data challenges. His talk, inspired by his blog post on ceposta Technology Blog, emphasized the importance of defining clear boundaries and leveraging event-driven technologies to achieve scalable, autonomous systems. This post delves into the key themes of Christian’s session, offering a comprehensive look at navigating data in microservices.
Understanding the Domain with DDD
Christian Posta began by addressing the critical need to understand the business domain when building microservices. He highlighted how DDD provides a framework for modeling complex domains by defining bounded contexts, entities, and aggregates. Using the example of a “book,” Christian illustrated how context shapes data definitions, such as distinguishing between a book as a single title versus multiple copies in a bookstore. This clarity, he argued, is essential for enterprises, where domains like insurance or finance are far more intricate than those of internet giants like Netflix. By grounding microservices in DDD, developers can create explicit boundaries that align with business needs, reducing ambiguity and fostering autonomy.
Defining Transactional Boundaries
Transitioning to transactional boundaries, Christian emphasized minimizing the scope of atomic operations to enhance scalability. He critiqued the traditional reliance on single, ACID-compliant databases, which often leads to brittle systems when applied to distributed architectures. Instead, he advocated for identifying the smallest units of business invariants, such as a single booking in a travel system, and managing them within bounded contexts. Christian’s insights, drawn from real-world projects, underscored the pitfalls of synchronous communication and the need for explicit boundaries to avoid coordination challenges like two-phase commits across services.
Event-Driven Communication with Apache Kafka
A core focus of Christian’s talk was the role of event-driven architectures in decoupling microservices. He introduced Apache Kafka as a backbone for streaming immutable events, enabling services to communicate without tight coupling. Christian explained how Kafka’s publish-subscribe model supports scalability and fault tolerance, allowing services to process events at their own pace. He highlighted practical applications, such as using Kafka to propagate changes across bounded contexts, ensuring eventual consistency while maintaining service autonomy. His demo showcased Kafka’s integration with microservices, illustrating its power in handling distributed data.
Leveraging Debezium for Data Synchronization
Christian also explored Debezium, an open-source platform for change data capture, to address historical data synchronization. He described how Debezium’s MySQL connector captures consistent snapshots and streams binlog changes to Kafka, enabling services to access past and present data. This approach, he noted, supports use cases where services need to synchronize from a specific point, such as “data from Monday.” Christian’s practical example demonstrated Debezium’s role in maintaining data integrity across distributed systems, reinforcing its value in microservices architectures.
Integrating Apache Camel for Robust Connectivity
Delving into connectivity, Christian showcased Apache Camel as a versatile integration framework for microservices. He explained how Camel facilitates communication between services by providing routing and transformation capabilities, complementing Kafka’s event streaming. Christian’s live demo illustrated Camel’s role in orchestrating data flows, ensuring seamless integration across heterogeneous systems. His experience as a committer on Camel underscored its reliability in building resilient microservices, particularly for enterprises transitioning from monolithic architectures.
Practical Implementation and Lessons Learned
Concluding, Christian presented a working example that tied together DDD, Kafka, Camel, and Debezium, demonstrating a cohesive microservices system. He emphasized the importance of explicit identity management, such as handling foreign keys across services, to maintain data integrity. Christian’s lessons, drawn from his work at Red Hat, highlighted the need for collaboration between developers and business stakeholders to refine domain models. His call to action encouraged attendees to explore these technologies and contribute to their open-source communities, fostering innovation in distributed systems.
Links:
[DevoxxUS2017] JavaScript: The New Parts by Joshua Wilson
At DevoxxUS2017, Joshua Wilson, a lead UI developer at Red Hat, delivered an illuminating session on ECMAScript 2015 (ES6) and its transformative features for JavaScript development. With a background transitioning from Java to front-end engineering, Joshua guided attendees through ES6’s modern syntax, including arrow functions, modules, and classes. His presentation offered practical insights for developers seeking to enhance their web development skills. This post explores the core themes of Joshua’s talk, focusing on ES6’s impact on coding elegance and productivity.
Embracing ES6 Features
Joshua Wilson began by introducing key ES6 features, such as arrow functions, which simplify syntax for function expressions, and let and const for block-scoped variables, enhancing code clarity. He demonstrated transforming legacy JavaScript into concise ES6 code, emphasizing improved readability. Drawing from his work at Red Hat, Joshua highlighted how these features streamline UI development, making JavaScript more approachable for developers accustomed to Java’s structure.
Modules and Classes for Modern Development
Delving deeper, Joshua explored ES6 modules, which enable better code organization and dependency management, contrasting them with older CommonJS approaches. He showcased ES6 classes, offering a familiar syntax for Java developers to create object-oriented structures. Joshua addressed challenges like handling null and undefined, noting ES6’s limited improvements but suggesting tools like TypeScript for stricter type safety, aligning with his focus on robust front-end solutions.
Practical Applications and Tooling
Joshua emphasized practical applications, demonstrating how ES6 integrates with build tools like Webpack for seamless module handling. He highlighted ES7’s Array.includes method for improved array searching, addressing edge cases like NaN. His insights, grounded in real-world UI projects at Red Hat, encouraged developers to adopt modern JavaScript practices, leveraging transpilers to ensure compatibility while embracing ES6’s expressive power.
Navigating the JavaScript Ecosystem
Concluding, Joshua encouraged developers to explore the evolving JavaScript ecosystem, recommending resources like Mozilla Developer Network (MDN) for learning ES6. His passion for front-end development inspired attendees to experiment with new syntax, enhancing their ability to craft dynamic, user-friendly interfaces with confidence.
Links:
[DevoxxBE2013] Part 1: Java EE 7: What’s New in the Java EE Platform
Antonio Goncalves and Arun Gupta, luminaries in Java EE advocacy, deliver a comprehensive exploration of Java EE 7’s advancements, blending simplification with expanded capabilities. Antonio, a senior architect and author of Beginning Java EE 6 Platform with GlassFish 3, collaborates with Arun, Red Hat’s Director of Developer Advocacy and former Java EE pioneer at Sun Microsystems, to unveil WebSocket, JSON processing, and enhanced CDI and JTA features. Their session, rich with demos, highlights how these innovations bolster HTML5 support and streamline enterprise development.
Java EE 7, they assert, refines container services while embracing modern web paradigms. From WebSocket’s real-time communication to CDI’s unified bean management, they showcase practical integrations, ensuring developers can craft scalable, responsive applications.
WebSocket for Real-Time Communication
Antonio introduces WebSocket, a cornerstone for HTML5’s bidirectional connectivity. He demonstrates @ServerEndpoint-annotated classes, crafting a chat application where messages flow instantly, bypassing HTTP’s overhead.
Arun details encoders/decoders, transforming POJOs to wire-ready text or binary frames, streamlining data exchange for real-time apps like live dashboards.
JSON Processing and JAX-RS Enhancements
Arun explores JSON-P (JSR 353), parsing and generating JSON with a fluid API. He demos building JSON objects from POJOs, integrating with JAX-RS’s HTTP client for seamless RESTful interactions.
This synergy, Antonio notes, equips developers to handle data-driven web applications, aligning with HTML5’s data-centric demands.
CDI and Managed Bean Alignment
Antonio unveils CDI’s evolution, unifying managed beans with injectable interceptors. He showcases constructor injection and method-level validation, simplifying dependency management across EJBs and servlets.
Arun highlights JTA’s declarative transactions, enabling @Transactional annotations to streamline database operations, reducing boilerplate.
Simplified JMS and Batch Processing
Arun introduces JMS 2.0’s simplified APIs, demonstrating streamlined message publishing. The new Batch API (JSR 352), Antonio adds, orchestrates chunk-based processing for large datasets, with demos showcasing job definitions.
These enhancements, they conclude, enhance usability, pruning legacy APIs while empowering enterprise scalability.
Resource Definitions and Community Engagement
Antonio details expanded resource definitions, configuring data sources via annotations. Arun encourages JCP involvement, noting Java EE 8’s community-driven roadmap.
Their demos—leveraging GlassFish—illustrate practical adoption, inviting developers to shape future specifications.
Links:
[DevoxxBE2013] OpenShift Primer: Get Your Applications into the Cloud
Eric D. Schabell, JBoss technology evangelist at Red Hat, demystifies OpenShift, a PaaS revolutionizing cloud deployment for Java EE, PHP, Ruby, and beyond. Author of the OpenShift Primer e-book, Eric—drawing from his integration and BPM expertise—guides attendees through rapid app migration, showcasing portability without code rewrites. His action-packed session deploys a Java project in minutes, contrasting OpenShift’s ease with cumbersome VMs.
OpenShift’s open-source ethos, Eric argues, delivers developer freedom: Git-based workflows, auto-scaling gears, and cartridge-based runtimes. From free tiers to enterprise scalability, it transforms cloud adoption, with European data centers addressing latency and privacy concerns.
Demystifying PaaS and OpenShift Fundamentals
Eric contrasts IaaS’s VM drudgery with PaaS’s streamlined abstraction. OpenShift, atop Red Hat Enterprise Linux, provisions environments via cartridges—pre-configured stacks for languages like Java.
He demos creating an app: rhc app create, Git push, and instant deployment, emphasizing no vendor lock-in.
Rapid Deployment and Portability
Portability reigns: Eric deploys a legacy Java EE app unchanged, leveraging JBoss EAP cartridges. PHP/Ruby examples follow, highlighting multi-language support.
This agnosticism, Eric notes, preserves investments, scaling from localhost to cloud seamlessly.
Scaling, Monitoring, and Security
Auto-scaling gears adjust to loads, Eric illustrates, with hot-deploy for zero-downtime updates. Monitoring via console tracks metrics; security integrates LDAP and SSL.
For Europe, Irish data centers mitigate latency, with GDPR-compliant options addressing data sovereignty.
Why OpenShift? Open-Source Advantages
Eric’s pitch: unmatched ease, no code changes, and open-source values. Free tiers on AWS East Coast suit demos, with paid plans offering local regions like Ireland.
He invites booth chats, contrasting OpenShift’s speed with competitors’ rigidity.
Links:
[DevoxxBE2013] Introducing Vert.x 2.0: Taking Polyglot Application Development to the Next Level
Tim Fox, the visionary project lead for Vert.x at Red Hat, charts the course of this lightweight, high-performance application platform for the JVM. With a storied tenure at JBoss and VMware—where he spearheaded HornetQ messaging and RabbitMQ integrations—Tim unveils Vert.x 2.0’s maturation into an independent powerhouse. His session delves into the revamped module system, Maven/Bintray reusability, and enhanced build tool/IDE synergy, alongside previews of Scala, Clojure support, and Node.js compatibility.
Vert.x 2.0 empowers polyglot, reactive applications, blending asynchronous eventing with synchronous legacy APIs via worker verticles. Tim’s live demos illustrate deploying modules dynamically, underscoring Vert.x’s ecosystem for mobile, web, and enterprise scalability.
Core API Refinements and Asynchronous Foundations
Tim highlights Vert.x’s event-driven core, refined in 2.0 with intuitive APIs for non-JVM languages. He demonstrates verticles—lightweight actors—for handling requests asynchronously, avoiding blocking calls.
This reactive model, Tim explains, scales to thousands of connections, ideal for real-time web apps, contrasting traditional thread-per-request pitfalls.
Module System and Ecosystem Expansion
The new module system, Tim showcases, leverages Maven repositories for seamless dependency management. He deploys a web server via module names, pulling artifacts from Bintray—eliminating manual installations.
This reusability fosters a vibrant ecosystem, with core modules for HTTP, MySQL (via reversed-engineered async drivers), and more, enabling rapid composition.
Build Tool and IDE Integration
Vert.x 2.0’s Maven/Gradle plugins streamline development, as Tim demos: configure a pom.xml, run mvn vertx:run, and launch a cluster. IDE support, via plugins, offers hot-reloading and debugging.
These integrations, Tim notes, lower barriers, allowing developers to iterate swiftly without Vert.x-specific tooling.
Polyglot Horizons: Scala, Clojure, and Node.js
Tim previews Scala/Clojure bindings, enabling functional paradigms on Vert.x’s event bus. Node.js compatibility, via drop-in modules, bridges JavaScript ecosystems, allowing polyglot teams to collaborate seamlessly.
This inclusivity, Tim asserts, broadens Vert.x’s appeal, supporting diverse languages without sacrificing performance.
Worker Verticles for Legacy Compatibility
For synchronous APIs like JDBC, Tim introduces worker verticles—executing on thread pools to prevent blocking. He contrasts with pure async MySQL drivers, offering flexibility for hybrid applications.
This pragmatic bridge, Tim emphasizes, integrates existing Java libraries effortlessly.
Links:
[DevoxxBE2013] Java EE 7’s Java API for WebSocket
Arun Gupta, Director of Developer Advocacy at Red Hat, unveils the transformative capabilities of the Java API for WebSocket in Java EE 7. A veteran of Sun Microsystems and Oracle, Arun has championed Java technologies globally, authoring extensive blogs and a best-selling book. His session explores WebSocket’s role in enabling efficient, bidirectional communication, eliminating the need for long polling or AJAX. Through live demonstrations, he illustrates server-side endpoints and client-side integrations, showcasing how this API empowers developers to craft responsive web and rich client applications.
WebSocket, a cornerstone of HTML5, facilitates real-time data exchange over a single TCP connection. Arun highlights its scalability, with GlassFish handling thousands of connections, and introduces tools like Autobahn for compliance testing. This API positions Java developers to build dynamic, scalable systems that complement RESTful architectures.
WebSocket Fundamentals and API Design
Arun introduces WebSocket’s departure from HTTP’s request-response model, leveraging a single, persistent connection. Using annotations like @ServerEndpoint, he demonstrates creating a chat application where messages flow instantly. The client API, accessible from browsers or Java applications, enables seamless integration.
This simplicity, Arun notes, reduces latency, making WebSocket ideal for real-time applications like live updates or collaborative tools.
Server-Side Scalability and Performance
Scalability is a key strength, Arun explains, with WebSocket supporting millions of file descriptors on Linux. He recounts Oracle’s GlassFish tests, achieving robust performance with thousands of connections. The Autobahn test suite, he suggests, validates compliance and load capacity.
Forthcoming WildFly tests, Arun adds, will further benchmark performance, ensuring reliability in production environments.
Complementing REST with WebSocket
Arun clarifies that WebSocket complements JAX-RS, not replaces it. He illustrates a hybrid design: REST for stateless queries, WebSocket for real-time updates. A stock ticker demo shows prices pushed to clients, blending both paradigms.
This synergy, Arun argues, enhances application flexibility, with Java EE 8 discussions exploring further integrations.
Community Engagement and Future Directions
Arun encourages joining Java EE expert groups, noting their transparent processes. Recent community gatherings, he mentions, discussed enhancing WebSocket’s role. He advocates contributing to shape Java EE 8, ensuring it meets developer needs.
This collaborative approach, Arun emphasizes, drives innovation, aligning WebSocket with evolving web standards.
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.