This document provides an overview of microservices and how to develop them using Spring. It discusses the challenges of distributed systems and how Spring Boot and Spring Cloud Netflix address areas like configuration, service registration, load balancing, fault tolerance, and monitoring. Examples are provided for building microservices with Spring Boot, integrating configuration with Spring Cloud Config, registering services with Eureka, load balancing with Ribbon and Feign, handling faults with Hystrix, and monitoring with Hystrix Dashboard. Reactive programming with RxJava is also introduced as an approach for concurrent API integration.
Microservices Platform with Spring Boot, Spring Cloud Config, Spring Cloud Ne...Tin Linn Soe
This document provides an overview of microservices architecture using Spring Boot, Eureka, and Spring Cloud. It describes using Spring Boot for cloud-native development, Eureka for service registration and discovery, Spring Cloud Config for distributed configuration, Zuul proxy for API gateway, Feign for communication between services, Sleuth for distributed request tracing, and demonstrates a sample application with three microservices that register with Eureka and fetch configurations from Config Server while communicating through Feign and tracing logs with Sleuth. Diagrams and code snippets are presented to illustrate the concepts and architecture.
Developing Resilient Cloud Native Apps with Spring CloudDustin Ruehle
Distributed and massively scalable systems are difficult to design, implement, and operate. Further, microservice architectures are supposed to enable your business to be disruptive and innovative. Thankfully, two communities have emerged to facilitate easier solutions for these concerns and do a lot of the work for you: Spring Cloud OSS and Cloud Foundry. In this talk, we will take a deeper look at preventing cascading failures using Hystrix, as well as illustrate a mechanism for A/B testing using Eureka and blue-green deployments on Cloud Foundry.
The document discusses improvements made to the Informix Java Driver (JDBC). It summarizes that the driver was modernized by: 1) Shortening build and test times from hours to minutes; 2) Adding over 100 new tests and API features for JDBC 4.0 compliance; and 3) Publishing the driver to Maven to simplify access and updates. Key changes included refactoring tests, adding metrics for quality, and allowing streaming of large objects from JDBC result sets.
Reactive Card Magic: Understanding Spring WebFlux and Project ReactorVMware Tanzu
Spring Framework 5.0 and Spring Boot 2.0 contain groundbreaking technologies known as reactive streams, which enable applications to utilize computing resources efficiently.
In this session, James Weaver will discuss the reactive capabilities of Spring, including WebFlux, WebClient, Project Reactor, and functional reactive programming. The session will be centered around a fun demonstration application that illustrates reactive operations in the context of manipulating playing cards.
Presenter : James Weaver, Pivotal
The document discusses continuous integration and continuous delivery workflows. It provides definitions and best practices for continuous integration, continuous delivery, and continuous deployment. It also summarizes the key concepts and components of ThoughtWorks Go including pipelines, stages, jobs, tasks, agents, and the value stream map for visualization. Pros and cons are listed for ThoughtWorks Go compared to Jenkins, noting Go's strengths in end-to-end visualization, fan-in support, and security configuration while Jenkins has more plugins and flexibility.
Jenkins Pipelining and Gatling IntegrationKnoldus Inc.
Jenkins is a continuous integration server written in Java. A Jenkins Pipeline (or simply "Pipeline" with a capital "P") is a suite of plugins which supports implementing and integrating continuous delivery pipelines into Jenkins.
The document discusses the importance of performance testing software systems. It notes that performance testing is a time-consuming process that requires planning infrastructure, building test data scenarios, running performance tests, analyzing results, and evaluating code and architecture. Specific and quantifiable performance metrics are needed to determine if a system passes or fails. The document recommends starting performance testing early in the development process and dedicating adequate time and isolated testing environments for it.
This document provides an overview of microservices and how to develop them using Spring. It discusses the challenges of distributed systems and how Spring Boot and Spring Cloud Netflix address areas like configuration, service registration, load balancing, fault tolerance, and monitoring. Examples are provided for building microservices with Spring Boot, integrating configuration with Spring Cloud Config, registering services with Eureka, load balancing with Ribbon and Feign, handling faults with Hystrix, and monitoring with Hystrix Dashboard. Reactive programming with RxJava is also introduced as an approach for concurrent API integration.
Microservices Platform with Spring Boot, Spring Cloud Config, Spring Cloud Ne...Tin Linn Soe
This document provides an overview of microservices architecture using Spring Boot, Eureka, and Spring Cloud. It describes using Spring Boot for cloud-native development, Eureka for service registration and discovery, Spring Cloud Config for distributed configuration, Zuul proxy for API gateway, Feign for communication between services, Sleuth for distributed request tracing, and demonstrates a sample application with three microservices that register with Eureka and fetch configurations from Config Server while communicating through Feign and tracing logs with Sleuth. Diagrams and code snippets are presented to illustrate the concepts and architecture.
Developing Resilient Cloud Native Apps with Spring CloudDustin Ruehle
Distributed and massively scalable systems are difficult to design, implement, and operate. Further, microservice architectures are supposed to enable your business to be disruptive and innovative. Thankfully, two communities have emerged to facilitate easier solutions for these concerns and do a lot of the work for you: Spring Cloud OSS and Cloud Foundry. In this talk, we will take a deeper look at preventing cascading failures using Hystrix, as well as illustrate a mechanism for A/B testing using Eureka and blue-green deployments on Cloud Foundry.
The document discusses improvements made to the Informix Java Driver (JDBC). It summarizes that the driver was modernized by: 1) Shortening build and test times from hours to minutes; 2) Adding over 100 new tests and API features for JDBC 4.0 compliance; and 3) Publishing the driver to Maven to simplify access and updates. Key changes included refactoring tests, adding metrics for quality, and allowing streaming of large objects from JDBC result sets.
Reactive Card Magic: Understanding Spring WebFlux and Project ReactorVMware Tanzu
Spring Framework 5.0 and Spring Boot 2.0 contain groundbreaking technologies known as reactive streams, which enable applications to utilize computing resources efficiently.
In this session, James Weaver will discuss the reactive capabilities of Spring, including WebFlux, WebClient, Project Reactor, and functional reactive programming. The session will be centered around a fun demonstration application that illustrates reactive operations in the context of manipulating playing cards.
Presenter : James Weaver, Pivotal
The document discusses continuous integration and continuous delivery workflows. It provides definitions and best practices for continuous integration, continuous delivery, and continuous deployment. It also summarizes the key concepts and components of ThoughtWorks Go including pipelines, stages, jobs, tasks, agents, and the value stream map for visualization. Pros and cons are listed for ThoughtWorks Go compared to Jenkins, noting Go's strengths in end-to-end visualization, fan-in support, and security configuration while Jenkins has more plugins and flexibility.
Jenkins Pipelining and Gatling IntegrationKnoldus Inc.
Jenkins is a continuous integration server written in Java. A Jenkins Pipeline (or simply "Pipeline" with a capital "P") is a suite of plugins which supports implementing and integrating continuous delivery pipelines into Jenkins.
The document discusses the importance of performance testing software systems. It notes that performance testing is a time-consuming process that requires planning infrastructure, building test data scenarios, running performance tests, analyzing results, and evaluating code and architecture. Specific and quantifiable performance metrics are needed to determine if a system passes or fails. The document recommends starting performance testing early in the development process and dedicating adequate time and isolated testing environments for it.
The document discusses building an orchestration layer for a travel agency service using JAX-RS 2.0 and Jersey 2. It describes a naive synchronous approach that makes sequential requests slowing performance, and proposes an optimized asynchronous approach using asynchronous requests to improve performance by processing requests concurrently instead of sequentially. It provides examples of synchronous and asynchronous client code to call external services.
Supercharged java 8 : with cyclops-reactJohn McClean
Overview of the rationale behind cyclops-react and some of it's features, including extended Java Collections, more powerful Sequential and Parallel Streaming, pattern matching, data types (such as Xor cyclops-react Either type, Maybe, Eval).
OSMC 2021 | inspectIT Ocelot: Dynamic OpenTelemetry Instrumentation at RuntimeNETWAYS
If you want to trace or extract specific data from a Java application with OpenTelemetry, you usually have to modify the application’s code. However, this is often not possible, especially with bought-in software. We would like to show, how the open source inspectIT Ocelot Java agent can be used to dynamically inject OpenTelemetry code at runtime for extracting specific application and business data – and all this without having to adapt the application itself.
Reactive programming by spring webflux - DN Scrum Breakfast - Nov 2018Scrum Breakfast Vietnam
Are you struggling to create a non-blocking REST application or a reactive micro-services? Spring WebFlux, a new module introduced by Spring 5 may help.
This new module introduces:
- Fully non-blocking
- Supports Reactive Streams back pressure
- Runs on such servers as Netty, Undertow, and Servlet 3.1+ containers
- Its support for the reactive programming model
In our next Scrum Breakfast, we will discuss Spring WebFlux, its benefit and how we implement it.
Our workshop will be including the following:
- What is reactive programming
- Introduction to Spring Webflux
- Tea break
- The details in Spring Webflux
- Reactive stack demonstration
- Q&A
Multi-threading in the modern era: Vertx Akka and QuasarGal Marder
Everybody wants scalable systems. However, writing non-blocking applications in Java is not an easy task. In this session, we'll go over 3 different frameworks for managing multi-treading and concurrency support (Akka, Vertx and Quasar).
Станислав Сидоренко «DeviceHive Java Server – миграция на Spring Boot»DataArt
The document discusses migrating the DeviceHive Java server from a Java EE implementation to a Spring Boot implementation. It describes DeviceHive as an open-source M2M framework that allows two-way communication with remote devices using cloud middleware. It then outlines some of the key components in the existing Java EE implementation and how they would map to Spring and Spring Boot, including using Spring MVC instead of JAX-RS, Spring services instead of EJBs, and deploying to Tomcat instead of a full Java EE server. It also discusses features of Spring Boot like easy deployment of standalone applications and auto-configuration of common dependencies.
This document provides an overview of performance testing with Gatling. It discusses introducing performance testing and the Gatling tool. The workshop mission is to cover introductions, modeling user scenarios, load modeling, and analysis in four parts. Part 1 provides an introduction to performance testing concepts like load testing and discusses common load testing tools. It introduces Gatling and has an exercise to record a test. Part 2 covers modeling realistic user scenarios with exercises. Part 3 discusses load modeling techniques and has an exercise. Part 4 discusses analysis and summarizes the workshop. The goal is to provide hands-on experience with Gatling for performance testing.
Advanced A/B Testing at Wix - Aviran Mordo and Sagy Rozman, Wix.comDevOpsDays Tel Aviv
While A/B test is a very known and familiar methodology for conducting experiments on production when you do that on a large scale it has many challenges in the organization level and operational level.
At Wix we are practicing continuous delivery for over 4 years. Conducting A/B tests and writing feature toggles is at the core of our development process. However when doing so on a large scale, with over 1000 experiments every month, it holds many challenges and affect everyone in the company, from developers, product managers, QA, marketing and management.
In this talk we will explain what is the lifecycle of an experiment, some of the challenges we faced and the effect on our development process.
* How an experiment begins its life
* How an experiment is defined
* How do you let non technical people control the experiment while preventing mistakes
* How an experiment go live, what is the lifecycle of an experiment from beginning to end
* What is the difference between client and server experiments
* How do you keep the user experience and not confuse them
* How does it affect the development process
* How can QA test an environment that changes every 9 minutes
* How can support help users when every user may be part of different experiment
* How can we find if an experiment is causing errors when you have millions of permutations [at least 2^(number of active experiments)]
* What are the effects of always having multiple experiments on system architecture
* What are the development patterns when working with AB test
At Wix we have developed our 3rd generation experiment system called PETRI, which is (will be) open sourced, that helps us maintain some order in a chaotic system that keep changing. We will also explain how PETRI works, what are the patterns in conducting experiments that will have a minimal effect on performance and user experience.
The document introduces reactive programming and RxJava. It defines reactive programming as working with asynchronous data streams using operators to combine, filter, and transform streams. It then discusses RxJava, a library that enables reactive programming in Java. It covers key reactive components like Observables, Operators, Schedulers, and Subjects. It provides examples of how to use various operators to transform, filter, combine streams and handle errors and backpressure. In conclusion, it discusses pros and cons of using reactive programming with RxJava.
This document discusses the history and current state of the Spring Framework and previews new features in Spring Framework 5. It outlines the challenges of blocking I/O and imperative code in traditional Spring applications and how Spring 5 aims to address this through support for reactive programming with Reactor and RxJava. Key new aspects of Spring 5 include Java 8 support, HTTP/2 integration, reactive controllers and routing, and integration of Reactive Streams for asynchronous non-blocking code.
This document provides an overview of reactive programming in Java and Spring 5. It discusses reactive programming concepts like reactive streams specification, Reactor library, and operators. It also covers how to build reactive applications with Spring WebFlux, including creating reactive controllers, routing with functional endpoints, using WebClient for HTTP requests, and testing with WebTestClient.
This document discusses different approaches for dependency injection in Go including:
1. Using package-level new functions to create dependencies and services.
2. Creating a "Super Factory" structure that embeds multiple dependency factories and can be used to initialize services and their dependencies with a uniform invocation mechanism.
3. Initializing a "Test Super Factory" for unit testing that can mock dependencies.
It analyzes the tradeoffs of different approaches and references additional resources on the topic.
How to implements the infra-structure for micro services? In this session, we'll compare building it with Spring Cloud vs. using Docker swarm/Kubernetes support.
This document discusses different levels of testing including unit, integration, system, and acceptance testing. It proposes using Jenkins pipelines for continuous testing and dividing tests into parallel parts to utilize CPUs more efficiently. Acceptance tests would be run using Docker, Docker Swarm, and Weave to deploy services and test integrations. System tests could use IPMI or cloud providers to perform automated installations and cron jobs. Reporting would include plugins for jUnit and performance results while a separate tool like Grafana would be better suited for displaying graphs and trends over time.
The document introduces RxJava, a library for composing asynchronous and event-based programs using observable sequences for the Java Virtual Machine. It discusses the problems with asynchronous programming, provides an overview of reactive programming and reactive extensions, and describes RxJava's core types like Observable and Observer. It also covers key concepts like operators, schedulers, subjects, and dealing with backpressure in RxJava.
Service discovery allows services in distributed systems to find and connect with each other. Popular open-source service discovery solutions include ZooKeeper, Eureka, ETCD, and Consul. ZooKeeper uses consensus protocol ZAB for consistency but clients must handle load balancing. Eureka is eventually consistent and Netflix uses it for AWS. ETCD is inspired by ZooKeeper but clients also handle load balancing. Consul uses RAFT consensus and has a built-in DNS server, making it a comprehensive solution. The right service discovery solution depends on requirements like consistency needs and language integration.
utPLSQL offers a unit testing API for PL/SQL that is modeled on the xUnit approach. This is an old slide deck on utPLSQL so my apologies for any inconsistencies with the current utility. Note: while I created the original utPLSQL code base, I am not actively working on utPLSQL at this time. Check out github.com/utplsql for the code and project details.
This document discusses testing strategies for data pipelines at scale. It recommends (1) communicating a testing strategy, (2) removing barriers to testing, (3) pursuing great staging environments, and (4) continuous end-to-end testing using a tool called Kafka Detective. Kafka Detective enables end-to-end testing by comparing data between staging and production Kafka topics and reporting any differences. The author details how Kafka Detective has found real issues in their pipelines and shares its features and roadmap for supporting more use cases.
This document contains an agenda and summaries of sections from a presentation on messaging architectures and using messaging data with Splunk. The agenda includes an overview of common messaging systems like JMS, AMQP, and Kafka. It also covers customizing message handling and scaling modular inputs. Additionally, it discusses using ZeroMQ to access messages and using underutilized computers with JMS tasks.
Jakarta EE is an open source Java platform that provides a wide range of APIs for building enterprise applications. It is made up of specifications covering areas like web services, security, and object-relational mapping. The document discusses the history and evolution of Jakarta EE, its relationship to other technologies like Spring and MicroProfile, and its importance for businesses, careers, and the Java ecosystem. It also outlines proposals for future versions like Jakarta EE 10 that aim to improve areas like security, messaging, and NoSQL support.
Deliver Faster with BDD/TDD - Designing Automated Tests That Don't SuckKevin Brockhoff
Kevin Brockhoff presented on accelerating software delivery through test-driven development (TDD) and behavior-driven development (BDD). TDD and BDD help identify incorrect behavior early, reduce rework, increase code confidence through automated tests, and improve code flexibility and extensibility. Brockhoff discussed key software delivery metrics like deployment frequency and change failure rate. He also covered testing best practices like the testing pyramid, unit testing frameworks, test source layout, and refactoring for testability.
The document discusses building an orchestration layer for a travel agency service using JAX-RS 2.0 and Jersey 2. It describes a naive synchronous approach that makes sequential requests slowing performance, and proposes an optimized asynchronous approach using asynchronous requests to improve performance by processing requests concurrently instead of sequentially. It provides examples of synchronous and asynchronous client code to call external services.
Supercharged java 8 : with cyclops-reactJohn McClean
Overview of the rationale behind cyclops-react and some of it's features, including extended Java Collections, more powerful Sequential and Parallel Streaming, pattern matching, data types (such as Xor cyclops-react Either type, Maybe, Eval).
OSMC 2021 | inspectIT Ocelot: Dynamic OpenTelemetry Instrumentation at RuntimeNETWAYS
If you want to trace or extract specific data from a Java application with OpenTelemetry, you usually have to modify the application’s code. However, this is often not possible, especially with bought-in software. We would like to show, how the open source inspectIT Ocelot Java agent can be used to dynamically inject OpenTelemetry code at runtime for extracting specific application and business data – and all this without having to adapt the application itself.
Reactive programming by spring webflux - DN Scrum Breakfast - Nov 2018Scrum Breakfast Vietnam
Are you struggling to create a non-blocking REST application or a reactive micro-services? Spring WebFlux, a new module introduced by Spring 5 may help.
This new module introduces:
- Fully non-blocking
- Supports Reactive Streams back pressure
- Runs on such servers as Netty, Undertow, and Servlet 3.1+ containers
- Its support for the reactive programming model
In our next Scrum Breakfast, we will discuss Spring WebFlux, its benefit and how we implement it.
Our workshop will be including the following:
- What is reactive programming
- Introduction to Spring Webflux
- Tea break
- The details in Spring Webflux
- Reactive stack demonstration
- Q&A
Multi-threading in the modern era: Vertx Akka and QuasarGal Marder
Everybody wants scalable systems. However, writing non-blocking applications in Java is not an easy task. In this session, we'll go over 3 different frameworks for managing multi-treading and concurrency support (Akka, Vertx and Quasar).
Станислав Сидоренко «DeviceHive Java Server – миграция на Spring Boot»DataArt
The document discusses migrating the DeviceHive Java server from a Java EE implementation to a Spring Boot implementation. It describes DeviceHive as an open-source M2M framework that allows two-way communication with remote devices using cloud middleware. It then outlines some of the key components in the existing Java EE implementation and how they would map to Spring and Spring Boot, including using Spring MVC instead of JAX-RS, Spring services instead of EJBs, and deploying to Tomcat instead of a full Java EE server. It also discusses features of Spring Boot like easy deployment of standalone applications and auto-configuration of common dependencies.
This document provides an overview of performance testing with Gatling. It discusses introducing performance testing and the Gatling tool. The workshop mission is to cover introductions, modeling user scenarios, load modeling, and analysis in four parts. Part 1 provides an introduction to performance testing concepts like load testing and discusses common load testing tools. It introduces Gatling and has an exercise to record a test. Part 2 covers modeling realistic user scenarios with exercises. Part 3 discusses load modeling techniques and has an exercise. Part 4 discusses analysis and summarizes the workshop. The goal is to provide hands-on experience with Gatling for performance testing.
Advanced A/B Testing at Wix - Aviran Mordo and Sagy Rozman, Wix.comDevOpsDays Tel Aviv
While A/B test is a very known and familiar methodology for conducting experiments on production when you do that on a large scale it has many challenges in the organization level and operational level.
At Wix we are practicing continuous delivery for over 4 years. Conducting A/B tests and writing feature toggles is at the core of our development process. However when doing so on a large scale, with over 1000 experiments every month, it holds many challenges and affect everyone in the company, from developers, product managers, QA, marketing and management.
In this talk we will explain what is the lifecycle of an experiment, some of the challenges we faced and the effect on our development process.
* How an experiment begins its life
* How an experiment is defined
* How do you let non technical people control the experiment while preventing mistakes
* How an experiment go live, what is the lifecycle of an experiment from beginning to end
* What is the difference between client and server experiments
* How do you keep the user experience and not confuse them
* How does it affect the development process
* How can QA test an environment that changes every 9 minutes
* How can support help users when every user may be part of different experiment
* How can we find if an experiment is causing errors when you have millions of permutations [at least 2^(number of active experiments)]
* What are the effects of always having multiple experiments on system architecture
* What are the development patterns when working with AB test
At Wix we have developed our 3rd generation experiment system called PETRI, which is (will be) open sourced, that helps us maintain some order in a chaotic system that keep changing. We will also explain how PETRI works, what are the patterns in conducting experiments that will have a minimal effect on performance and user experience.
The document introduces reactive programming and RxJava. It defines reactive programming as working with asynchronous data streams using operators to combine, filter, and transform streams. It then discusses RxJava, a library that enables reactive programming in Java. It covers key reactive components like Observables, Operators, Schedulers, and Subjects. It provides examples of how to use various operators to transform, filter, combine streams and handle errors and backpressure. In conclusion, it discusses pros and cons of using reactive programming with RxJava.
This document discusses the history and current state of the Spring Framework and previews new features in Spring Framework 5. It outlines the challenges of blocking I/O and imperative code in traditional Spring applications and how Spring 5 aims to address this through support for reactive programming with Reactor and RxJava. Key new aspects of Spring 5 include Java 8 support, HTTP/2 integration, reactive controllers and routing, and integration of Reactive Streams for asynchronous non-blocking code.
This document provides an overview of reactive programming in Java and Spring 5. It discusses reactive programming concepts like reactive streams specification, Reactor library, and operators. It also covers how to build reactive applications with Spring WebFlux, including creating reactive controllers, routing with functional endpoints, using WebClient for HTTP requests, and testing with WebTestClient.
This document discusses different approaches for dependency injection in Go including:
1. Using package-level new functions to create dependencies and services.
2. Creating a "Super Factory" structure that embeds multiple dependency factories and can be used to initialize services and their dependencies with a uniform invocation mechanism.
3. Initializing a "Test Super Factory" for unit testing that can mock dependencies.
It analyzes the tradeoffs of different approaches and references additional resources on the topic.
How to implements the infra-structure for micro services? In this session, we'll compare building it with Spring Cloud vs. using Docker swarm/Kubernetes support.
This document discusses different levels of testing including unit, integration, system, and acceptance testing. It proposes using Jenkins pipelines for continuous testing and dividing tests into parallel parts to utilize CPUs more efficiently. Acceptance tests would be run using Docker, Docker Swarm, and Weave to deploy services and test integrations. System tests could use IPMI or cloud providers to perform automated installations and cron jobs. Reporting would include plugins for jUnit and performance results while a separate tool like Grafana would be better suited for displaying graphs and trends over time.
The document introduces RxJava, a library for composing asynchronous and event-based programs using observable sequences for the Java Virtual Machine. It discusses the problems with asynchronous programming, provides an overview of reactive programming and reactive extensions, and describes RxJava's core types like Observable and Observer. It also covers key concepts like operators, schedulers, subjects, and dealing with backpressure in RxJava.
Service discovery allows services in distributed systems to find and connect with each other. Popular open-source service discovery solutions include ZooKeeper, Eureka, ETCD, and Consul. ZooKeeper uses consensus protocol ZAB for consistency but clients must handle load balancing. Eureka is eventually consistent and Netflix uses it for AWS. ETCD is inspired by ZooKeeper but clients also handle load balancing. Consul uses RAFT consensus and has a built-in DNS server, making it a comprehensive solution. The right service discovery solution depends on requirements like consistency needs and language integration.
utPLSQL offers a unit testing API for PL/SQL that is modeled on the xUnit approach. This is an old slide deck on utPLSQL so my apologies for any inconsistencies with the current utility. Note: while I created the original utPLSQL code base, I am not actively working on utPLSQL at this time. Check out github.com/utplsql for the code and project details.
This document discusses testing strategies for data pipelines at scale. It recommends (1) communicating a testing strategy, (2) removing barriers to testing, (3) pursuing great staging environments, and (4) continuous end-to-end testing using a tool called Kafka Detective. Kafka Detective enables end-to-end testing by comparing data between staging and production Kafka topics and reporting any differences. The author details how Kafka Detective has found real issues in their pipelines and shares its features and roadmap for supporting more use cases.
This document contains an agenda and summaries of sections from a presentation on messaging architectures and using messaging data with Splunk. The agenda includes an overview of common messaging systems like JMS, AMQP, and Kafka. It also covers customizing message handling and scaling modular inputs. Additionally, it discusses using ZeroMQ to access messages and using underutilized computers with JMS tasks.
Jakarta EE is an open source Java platform that provides a wide range of APIs for building enterprise applications. It is made up of specifications covering areas like web services, security, and object-relational mapping. The document discusses the history and evolution of Jakarta EE, its relationship to other technologies like Spring and MicroProfile, and its importance for businesses, careers, and the Java ecosystem. It also outlines proposals for future versions like Jakarta EE 10 that aim to improve areas like security, messaging, and NoSQL support.
Deliver Faster with BDD/TDD - Designing Automated Tests That Don't SuckKevin Brockhoff
Kevin Brockhoff presented on accelerating software delivery through test-driven development (TDD) and behavior-driven development (BDD). TDD and BDD help identify incorrect behavior early, reduce rework, increase code confidence through automated tests, and improve code flexibility and extensibility. Brockhoff discussed key software delivery metrics like deployment frequency and change failure rate. He also covered testing best practices like the testing pyramid, unit testing frameworks, test source layout, and refactoring for testability.
Video at https://www.youtube.com/watch?v=nD1eFbql8jg
This talk will demonstrate advanced testing practices used by the XWiki open source project, and using Java, Maven, Docker and Jenkins:
* Testing for backward compatibility with Revapi and an associated strategy
* Testing for coverage with Jacoco and defining a viable strategy for slowing improving the situation
* Testing the quality of your tests with Descartes Mutation testing
Automatically enriching your test suite with DSpot
* Testing various configurations with Docker containers and Jenkins
The world is moving from a model where data sits at rest, waiting for people to make requests of it, to where data is constantly moving, streams of data flow to and from devices with or without human interaction. Decisions need to be made based on these streams of data in real time, models need to be updated, intelligence needs to be learned. And our old-fashioned approach of CRUD REST APIs serving CRUD database calls just doesn't cut it, it's trying to fit a square peg into a round hole. It's time we moved to a stream-centric view of the world.
This talk will look at how Reactive Streams is shaping the future of Jakarta EE. I'll talk about some Reactive Streams based specifications that we're currently working on in the JDK, MicroProfile and Jakarta EE communities, as well as some potential big ideas to transform the way developers write their applications, such as event sourcing and CQRS, that Jakarta EE will likely adopt in future. We'll take a look at a hypothetical future Jakarta EE, at what a typical service will look like when streaming is embraced, and get a glimpse of how Jakarta EE can lead the world in standards for Reactive systems.
The world is moving from a model where data sits at rest, waiting for people to make requests of it, to where data is constantly moving and streams of data flow to and from devices with or without human interaction. Decisions need to be made based on these streams of data in real-time, models need to be updated, and intelligence needs to be gathered. In this context, our old-fashioned approach of CRUD REST APIs serving CRUD database calls just doesn't cut it. It's time we moved to a stream-centric view of the world.
Performance Test Driven Development with Oracle Coherencearagozin
This presentation discusses test driven development with Oracle Coherence. It outlines the philosophy of PTDD and challenges of testing Coherence, including the need for a cluster and sensitivity to network issues. It discusses automating tests using tools like NanoCloud for managing nodes and executing tests remotely. Different types of tests are described like microbenchmarks, performance regression tests, and bottleneck analysis. Common pitfalls of performance testing like fixed users vs fixed request rates are also covered.
This document discusses Jetty Continuation, which allows suspending and resuming HTTP requests in Jetty. It allows one thread to handle multiple requests asynchronously. With Continuation, thread usage can be reduced by suspending requests during asynchronous operations and resuming them on completion. Listeners can be used to handle request completion or timeout. Continuations provide asynchronous servlet processing capabilities to Jetty.
Level Up Your Integration Testing With TestcontainersVMware Tanzu
The document discusses Testcontainers, a Java library that makes it easy to create lightweight, disposable Docker containers to support integration testing. Testcontainers allows developers to start containers for databases, browsers, and other services via simple annotations and eliminates the need to manage complex Docker configurations and container lifecycles manually. It integrates with JUnit and handles starting a new container before each test and cleaning it up afterwards, improving testing fidelity by mimicking production environments.
Java 9 is expected to include several new features and changes, including:
- New collection factory methods like Set.of() and Map.of() that provide immutable collections.
- Enhancements to the Stream API such as takeWhile() and dropWhile().
- Syntax changes like allowing effectively final variables in try-with-resources and @SafeVarargs for private methods.
- The addition of JShell to provide a Java REPL.
- Garbage First (G1) garbage collector becoming the default collector.
- Various performance and logging improvements.
This document describes Cerberus, an open source test automation tool developed by La Redoute. Cerberus allows centralized management of test cases across multiple technologies like web, mobile, and APIs. It supports features like a step library, test automation, execution reporting, and integration with other tools. The document also provides examples of how Cerberus is used at La Redoute for regression testing websites in multiple languages and environments. It maintains over 3,500 regression tests that execute twice daily. Cerberus can also be used for functional monitoring of websites by regularly executing test cases and monitoring performance metrics.
The document discusses the Servlet 4.0 specification led by Ed Burns and Dr. Shing-Wai Chan. It provides an overview of the major new features of HTTP/2 including request/response multiplexing, binary framing, stream prioritization, server push, and header compression. It then outlines how features like server push could potentially be exposed through the Servlet API in Servlet 4.0. It concludes with an invitation for the community to contribute to the JSR-369 page by providing a list of JIRA components, use cases for sessionless applications, and references to async and thread safety in the specification and documentation.
Test it! Unit, mocking and in-container Meet Arquillian!Ivan Ivanov
A gentle introduction into testing in Java. Begin with testing a single unit, continue with mocking dependency and end up with a full incontainer test capabilities.
Abstract 2: "Advanced testing in action on a Java project"
In 2019 we're all used to writing automated tests in Java projects. It's now time to move up the chain and learn how to implement more complex type of testing.
This talk will demonstrate advanced testing practices used by the XWiki open source project (http://xwiki.org), and using Java, Maven, Docker and Jenkins and more:
* Testing for backward compatibility with Revapi and an associated strategy
* Testing for coverage with Jacoco and defining a viable strategy for slowing improving the situation
* Testing the quality of your tests with Descartes Mutation testing
* Automatically enriching your test suite with DSpot
* Testing various configurations with Docker containers and Jenkins
1) Ansible is being used at Backbase to automate the provisioning of different server configurations for testing their Customer Experience Platform (CXP).
2) A REST API and UI allow users to easily provision new environments from available server stacks configured with Ansible for testing.
3) This enables Backbase to implement continuous delivery practices like automated testing of new versions without affecting production environments.
The document discusses the transition from Java EE to Jakarta EE. It provides details on Oracle's contributions to the Eclipse EE4J project including source code for GlassFish and TCKs. It summarizes the key differences between Oracle GlassFish 5.0 and Eclipse GlassFish 5.1. It also discusses Oracle's future plans regarding WebLogic Server, Java EE, and emerging technologies like Kubernetes and GraalVM.
Josh Juneau gives a whirlwind tour of migrating to Jakarta EE 10. He discusses the changes from Jakarta EE 8 to EE 10 including moving to the Eclipse Foundation and namespace changes. He demonstrates how to get started with EE 10 and highlights new features in concurrency, CDI, JSON processing, and security. Strategies for upgrading projects to EE 10 like manual changes or using utilities are presented. Finally, he outlines what is coming in the next EE 11 release.
The world is moving from a model where data sits at rest, waiting for people to make requests of it, to where data is constantly moving and streams of data flow to and from devices with or without human interaction. Decisions need to be made based on these streams of data in real-time, models need to be updated, and intelligence needs to be gathered. In this context, our old-fashioned approach of CRUD REST APIs serving CRUD database calls just doesn't cut it. It's time we moved to a stream-centric view of the world.
https://jonthebeach.com/speakers/71/Markus+Eisele
Embracing Disruption: Adding a Bit of Chaos to Help You GrowPaul Balogh
** Recording available at https://www.youtube.com/watch?v=sHNOjUtbq2s **
Failure happens! It's our job to turn these disruptions into learning opportunities. As our software has become more distributed and complex, the "shift-left" movement brings reliability testing to earlier stages of development. Ensuring reliability goes beyond simple end-to-end tests.
To ensure the highest levels of reliability, you must perform a suite of testing types. Incorporate contract tests to validate APIs; load tests for scaling predictability. Let's learn from Chaos Engineering principles by incorporating disruptive behavior into your system _before_ production.
Join Paul as we learn ways to incorporate a plethora of testing into your software development pipeline. We'll discuss the pros and cons of each and what you can do to add these to your processes.
By embracing a little disruption, you can significantly improve the reliability of your system.
Similar to Lightweight Java EE with MicroProfile (20)
This document provides an overview and agenda for a presentation on code recipes using various Jakarta EE APIs. It discusses getting started with Eclipse GlassFish or Payara and incorporating Jakarta EE specifications into projects. It then presents problems and solutions demonstrating the Jakarta RESTful Web Services, JSON-B, JSON Patch, Concurrency APIs and more. Code examples are provided on GitHub for consuming, processing and displaying RESTful data across frontend, service and database tiers.
The document discusses Jakarta EE and MicroProfile features. Josh Juneau and Edwin Derks will demonstrate key but less commonly used features of Jakarta EE and MicroProfile, including asynchronous CDI events, JSON binding, JSON processing, security, and fault tolerance annotations. They will also cover deploying applications as Docker images.
Jakarta EE and MicroProfile - EclipseCon 2020Josh Juneau
The document discusses Jakarta EE and MicroProfile features, including demonstrations of asynchronous CDI events, JSON binding and processing, RESTful web services with server-sent events, security, validation, persistence, websockets, health checks, configuration injection, REST clients, and fault tolerance. It also mentions including dependencies in Docker images.
Utilizing JSF Front Ends with MicroservicesJosh Juneau
The document discusses utilizing Jakarta Server Faces and Jakarta RESTful Web Services to build front ends for microservices. It provides an overview of the technologies and frameworks, including new features of JSF 2.3 and Jakarta RESTful Web Services. It then demonstrates how to create a simple RESTful service using JAX-RS and JPA, and build a JSF front end to communicate with the service and display database data. The presentation recommends approaches for writing and modifying data via REST, securing services, and using various Java EE and third-party libraries.
In this session, we take a look at a handful of the features that will be part of the upcoming Java EE 8 release, as well as a few of the existing features that can be utilized in Java EE 7 today. Each of the features are presented via a recipe in the "Problem", "Solution", and "How it Works" format.
Java EE 8 Web Frameworks: A Look at JSF vs MVCJosh Juneau
This session provides an overview of both the JSF and MVC 1.0 frameworks. The frameworks are then compared to each other. Finally, JSF 2.3 upcoming features are previewed.
Java EE 8 will include updates to several existing specifications as well as new specifications. Key updates include JMS 2.1, JAX-RS 2.1, JSF 2.3, CDI 2.0, and JSON-P 1.1. New specifications include JCache 1.0, JSON-B 1.0, MVC 1.0, and Java EE Security API 1.0. Java EE 8 is currently in development, with early drafts of specifications and milestones available to provide feedback on. A final release is planned for Q3 2016.
Java EE 7 Recipes for Concurrency - JavaOne 2014Josh Juneau
Josh Juneau presented on using the Concurrency Utilities in Java EE 7 to resolve real world concurrency scenarios in an application called AcmeWorld. The utilities provide standard managed concurrent resources like managed executor services, scheduled executor services, managed threads and context services. Example problems demonstrated how to execute long-running tasks asynchronously, schedule periodic tasks, propagate contexts between threads and monitor asynchronous task lifecycles. The presentation provided code examples and instructions for interacting with the managed concurrent resources in Java EE 7 application servers.
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
Enchancing adoption of Open Source Libraries. A case study on Albumentations.AIVladimir Iglovikov, Ph.D.
Presented by Vladimir Iglovikov:
- https://www.linkedin.com/in/iglovikov/
- https://x.com/viglovikov
- https://www.instagram.com/ternaus/
This presentation delves into the journey of Albumentations.ai, a highly successful open-source library for data augmentation.
Created out of a necessity for superior performance in Kaggle competitions, Albumentations has grown to become a widely used tool among data scientists and machine learning practitioners.
This case study covers various aspects, including:
People: The contributors and community that have supported Albumentations.
Metrics: The success indicators such as downloads, daily active users, GitHub stars, and financial contributions.
Challenges: The hurdles in monetizing open-source projects and measuring user engagement.
Development Practices: Best practices for creating, maintaining, and scaling open-source libraries, including code hygiene, CI/CD, and fast iteration.
Community Building: Strategies for making adoption easy, iterating quickly, and fostering a vibrant, engaged community.
Marketing: Both online and offline marketing tactics, focusing on real, impactful interactions and collaborations.
Mental Health: Maintaining balance and not feeling pressured by user demands.
Key insights include the importance of automation, making the adoption process seamless, and leveraging offline interactions for marketing. The presentation also emphasizes the need for continuous small improvements and building a friendly, inclusive community that contributes to the project's growth.
Vladimir Iglovikov brings his extensive experience as a Kaggle Grandmaster, ex-Staff ML Engineer at Lyft, sharing valuable lessons and practical advice for anyone looking to enhance the adoption of their open-source projects.
Explore more about Albumentations and join the community at:
GitHub: https://github.com/albumentations-team/albumentations
Website: https://albumentations.ai/
LinkedIn: https://www.linkedin.com/company/100504475
Twitter: https://x.com/albumentations
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
2. About Me
Josh Juneau
• Java EE, JakartaEE, Java SE, Databases, Jython/Groovy
• Fermi National Accelerator Laboratory
• Author/Presenter/Podcaster
• JCP Member, JSF 2.3 Expert Group
• CJUG Open Source Software Initiative
• Eclipse Foundation Member, Mojarra Committer
• Apache NetBeans Developer
3. What’s Happening
in Java Enterprise?
Jakarta EE Status
• Java EE 8 APIs are being transferred to EE4J
project
• Eclipse GlassFish 5.1 Now Available (RC)
• Target release date 12/14/2018
• Initial Release is Imminent
• Status https://www.eclipse.org/ee4j/status.php
Java EE 8 == Jakarta EE 8
4. What’s Happening
in Java Enterprise?
Specification Process
• JCP No Longer Used for Java EE
• Jakarta EE Specification Process
• Lightweight
• ~ Open Source
All contributions are now complete
Java EE TCKs open sourced
Nightly builds of GlassFish 5.1 available
5. In the Meantime
Test out Jakarta EE using EE4J Projects
Download Eclipse GlassFish and test
Utilize MicroProfile for agile Java EE development
and Microservice toolset
6. MicroProfile
• Started in 2016 by a community of individuals,
organizations, and vendors do collaborate on a
standard approach for bringing microservices to Java
• Open source community specification for Enterprise
Java microservices
• 6 Overall releases & 16 individual spec releases
• Began small (3 APIs in 1.0)
9. MicroProfile
- Geared towards developing Microservices for cloud
- MicroProfile provides the following features that support
reactive programming:
• Reactive REST client (via JAX-RS)
• Server-Sent Events (SSE) server and client (via JAX-
RS)
• Asynchronous events (via CDI)
• Metrics and Health endpoints to react to resource
usage and service failures
• https://wiki.eclipse.org/MicroProfile/
Implementation#Eclipse_MicroProfile_Releases
•
10.
11.
12. Config
• Standard means of storing configuration
outside of an application
• Utilize annotations
• Property files, system properties,
environment variables
13.
14. Fault Tolerance
• Leverage different strategies to guide
the execution and results of some
logic
• Examples include retry policies,
bulkheads, and circuit breakers
• Determine what should occur when an
expected result is not achieved
16. Fault Tolerance
Bulkhead
• Bulkhead: Pattern to prevent faults in
one part of a system from taking down
everything.
@Bulkhead(5) // maximum 5 concurrent
public Connection serviceA(){
Connection conn = null;
conn = connectionService();
return conn;
}
21. Metrics
• This is a key API for monitoring distributed
systems
• Standard means for exporting monitoring
data
• Allows developers a means to build
application metrics
• Adds well known endpoints and values for
each process
22. Metrics• Three Scopes: Base, Vendor, Application
• /metrics/base
• /metrics/vendor
• /metrics/application
Application Annotations:
@Counted, @Gauge, @Metered, @Timed
Histogram: Measures the distribution of
values in a stream of data and allows you
to measure, not just natural things like the
min, mean, max, and standard deviation
of values, but also quantiles like the
median or 95th percentile.
23.
24. Open Tracing
Follow requests within a distributed environment,
instrumenting microservices for distributed
tracing.
Enterprise Java binding to the Open Tracing
specification.
25. Open Tracing 1.2
Updates:
By default, Open Tracing will not trace endpoints
associated with MicroProfile Metrics, Health
and OpenAPI
Added logging exceptions thrown by explicit
instrumentation (@Traced)
Added server operation name provider
Removed geronimo-atinject and javax.annotation
dependencies for API module
Added support for server side skip pattern
26. Open API
• Generates OpenAPI Documents from
JAX-RS endpoints
• Utilizes Swagger UI
• WSDL For REST
27. REST Client
• Easy to use API for working with a REST
client
• Let verbose than standard invocation