This document discusses using a portlet API-based approach for integrating applications into Magnolia. It describes the portlet API concept of separate action and render phases. Implementing portlets as JSR-168 components allows seamless integration into Magnolia by adding a portlet filter and rendering portlets during page generation. Configuration is done through content types and portlet parameters can be accessed. Real-world use has shown this approach works well for small applications but has limitations for more complex integrations.
Java9 Beyond Modularity - Java 9 más allá de la modularidadDavid Gómez García
These are the slides I used for my "Java 9 beyond modularity" at several different local meetups and conferences in Spain during 2017
Java 9 is about to reach its public release scheduled for September 2017. If we ask what are the new features that this new version will include, probably the first that comes to our head is modularity.
But java 9 brings with a lot of features beyound Jigsaw, JPMS or modularity. In this talk we will talk about at least 9 other new features that include this new version of Java that are interesting and maybe will end up being more used than the modularity itself for those who embrace the new version.
Those are changes that come to complement and improve even more the set of new tools (like Streams, Optionals, etc...) that Java 8 brought to us.
We'll take a look at small changes in language syntax (such as new ways of using try-with-resources), changes in Collections APIs and Streams, new tools like VarHandles, new APIs such as the Flow API, and As we allow the inclusion of reactive programming with Java.
Do you want to see in Java 9 beyond modularity? Do you want to have a more complete view of what you can provide? Let's take a look toghether!
Developing ASP.NET Applications Using the Model View Controller Patterngoodfriday
MVC provides a new web project type for ASP.NET that allows for more control over HTML and a more testable framework. It maintains a clean separation of concerns between models, views, and controllers and allows developers to easily extend or replace any component. MVC supports RESTful URLs, integrates well with existing ASP.NET features, and enables test-driven development through mockable abstractions.
Powerful persistence layer with Google Guice & MyBatissimonetripodi
This document discusses integrating MyBatis, an object-relational mapping tool, with Google Guice for dependency injection. It describes how MyBatis is a fork of Apache iBATIS and the history of the Guice integration project. It also covers how to configure MyBatis using Guice modules, inject mappers, handle transactions with annotations, support various data sources, and provide JDBC helpers.
The document discusses Oracle Application Development Framework (ADF) bindings. It provides an overview of ADF model layers and artifacts like the page definition file. It describes how bindings are used in the ADF lifecycle during processes like restoring the view and rendering the response. It also discusses accessing and executing bindings programmatically.
Take a look at what Rails 5 has in store for you. We go through all the new features and improvements across development, testing, caching and much more. So let's dive in.
Pre-conference seminar from the March 2010, Jasig (www.jasig.org) conference in San Diego, CA.
Additional presentation materials are available at the following page - http://www.ja-sig.org/wiki/display/JCON/JSR+286+Seminar+March+2010
Java9 Beyond Modularity - Java 9 más allá de la modularidadDavid Gómez García
These are the slides I used for my "Java 9 beyond modularity" at several different local meetups and conferences in Spain during 2017
Java 9 is about to reach its public release scheduled for September 2017. If we ask what are the new features that this new version will include, probably the first that comes to our head is modularity.
But java 9 brings with a lot of features beyound Jigsaw, JPMS or modularity. In this talk we will talk about at least 9 other new features that include this new version of Java that are interesting and maybe will end up being more used than the modularity itself for those who embrace the new version.
Those are changes that come to complement and improve even more the set of new tools (like Streams, Optionals, etc...) that Java 8 brought to us.
We'll take a look at small changes in language syntax (such as new ways of using try-with-resources), changes in Collections APIs and Streams, new tools like VarHandles, new APIs such as the Flow API, and As we allow the inclusion of reactive programming with Java.
Do you want to see in Java 9 beyond modularity? Do you want to have a more complete view of what you can provide? Let's take a look toghether!
Developing ASP.NET Applications Using the Model View Controller Patterngoodfriday
MVC provides a new web project type for ASP.NET that allows for more control over HTML and a more testable framework. It maintains a clean separation of concerns between models, views, and controllers and allows developers to easily extend or replace any component. MVC supports RESTful URLs, integrates well with existing ASP.NET features, and enables test-driven development through mockable abstractions.
Powerful persistence layer with Google Guice & MyBatissimonetripodi
This document discusses integrating MyBatis, an object-relational mapping tool, with Google Guice for dependency injection. It describes how MyBatis is a fork of Apache iBATIS and the history of the Guice integration project. It also covers how to configure MyBatis using Guice modules, inject mappers, handle transactions with annotations, support various data sources, and provide JDBC helpers.
The document discusses Oracle Application Development Framework (ADF) bindings. It provides an overview of ADF model layers and artifacts like the page definition file. It describes how bindings are used in the ADF lifecycle during processes like restoring the view and rendering the response. It also discusses accessing and executing bindings programmatically.
Take a look at what Rails 5 has in store for you. We go through all the new features and improvements across development, testing, caching and much more. So let's dive in.
Pre-conference seminar from the March 2010, Jasig (www.jasig.org) conference in San Diego, CA.
Additional presentation materials are available at the following page - http://www.ja-sig.org/wiki/display/JCON/JSR+286+Seminar+March+2010
The document discusses frontend frameworks for Rails 6, comparing the asset pipeline and webpack. It covers problems with the asset pipeline like slowness and lack of ES6 support. Webpack solves these issues through its module bundler capabilities and loaders/plugins. Stimulus.js is presented as a simple option to manage state in the browser via data attributes. React with Redux is discussed as another option but challenges mixing their state with Rails are noted. Integrating frameworks like React, Angular, Vue, Stimulus and Svelte with Rails via Webpacker is mentioned. Examples of React/Redux and Stimulus usage are provided.
For years i wanted a robust solution to organize code:
Eliminate messy code
Organize structure
Set strict rules for apps
Write simple tests that cover exactly what i need
Write Less, Think Less - Do More
I just wanted a simple hands-on philosophy in my code.
Then came NgRx/store.
This is an intro to ngrx/store and its echo-system with a usecase of Echoes Player (ng2) open source player developed with angular 2 and ngrx/store.
This document provides an overview of Java Server Pages (JSP) technology. It discusses JSP architecture and components like expressions, scriptlets, declarations, comments, directives, standard actions, implicit objects, and JavaBeans. Expression Language (EL) is also introduced, which allows accessing Java objects in JSP using a simpler syntax. Key elements like scopes, operators, and implicit objects available in EL are explained.
This 50 minutes talk covers the novelties of Java EE 7 (easier to understand if you already know Java EE 6). It comes from the talk I gave with Arun Gupta at JavaOne 2013
Simplified Android Development with Simple-StackGabor Varadi
This talk describes multiple Activities, Jetpack Navigation, and Simple-Stack in a single-activity android application context. How to develop screens and navigation using Simple-Stack.
В презентации описаны лучшие практики использования библиотеки React в связке с Redux. Быстрое разворачивание SPA без настройки Webpack и Babel с помощью утилиты Create React App, Smart and Dumb, Stateful and Stateless Components, управление рендером с помощью shouldComponentUpdate, Redux модули, мемоизация и middlewares.
More useful info on our:
- website: https://clickky.biz
- blog: https://clickky.biz/blog
Sign up!
Redux - idealne dopełnienie Reacta. Prezentacja przedstawiona na warsztatach z podstaw technologii Redux w ramach DreamLab Academy.
W razie pytań zapraszamy do kontaktu academy@dreamlab.pl
The presentation has been part of DreamLab Academy workshop on Redux. For more details get in touch - academy@dreamlab.pl
The document discusses building native components and modules for React Native applications. It provides guidance on creating native modules and components for both iOS and Android platforms. For native modules, it describes how to expose methods and properties to JavaScript. For native components, it explains how to create custom native views and expose their properties and events to React components.
This document provides an introduction to React for developers. It explains that React is a JavaScript library for building user interfaces developed by Facebook. It then covers key React concepts like components, props, state, rendering, and the virtual DOM. It also discusses tools and patterns for architecting React apps like Flux, Redux, routing, internationalization, and async logic. Finally, it recommends designing state carefully, using standards like Flux Standard Action, avoiding side effects in reducers, and leveraging tools like React DevTools.
Leveraging Completable Futures to handle your query results AsynchrhonouslyDavid Gómez García
The document discusses leveraging CompletableFutures to handle asynchronous query results in Java. It begins with an overview of concurrency vs parallelism and tools in Java for concurrency. It then covers using ExecutorServices and Futures to run tasks asynchronously before introducing CompletableFutures, which allow fluent chaining and composition of dependent asynchronous tasks. Examples are provided of using CompletableFutures to run database queries asynchronously and maximize performance. Considerations for using CompletableFutures in APIs are also discussed.
Architecting Single Activity Applications (With or Without Fragments)Gabor Varadi
Presentation by Gabor Varadi (@zhuinden)
What Activity and Fragment actually are in Android
What are the problems they solve, and what are their downsides
How to use a custom solution that simplifies navigation in Android applications
https://github.com/Zhuinden/navigation-example
Quick introduction into react and flux followed by a comparison of redux and alt flux frameworks and a simple hello world application implemented in each of them. Last two slides present a microservices approach to client side applications as one of approaches how to make transitions between frameworks easier.
Value types are at the core of Swift (seriously, mostly everything in the Swift standard library is a value type). But how do you avoid subclassing? That’s where the power of Protocol-Oriented programming comes in. Learn how to structure your code to never subclass (almost) again! Practical everyday examples and ideas for your own code base will be included.
This document discusses Spring MVC annotations used in controller classes. The @Controller annotation marks a class as a controller. The @RequestMapping annotation maps requests to controller methods. @PathVariable binds path variables to method parameters. @RequestParam binds query parameters. @RequestBody and @ResponseBody bind request/response bodies. Supported method argument and return types are also described.
The document provides an overview of state management in Angular using NgRx. It discusses setting up the store and reducers, accessing state in components, using selectors, handling asynchronous operations with effects, improving data persistence with NX, and connecting related data models. The key steps covered include creating interfaces and initial state, setting up the reducer, importing modules, dispatching actions, using entity adapters for collections, and composing selectors.
AngularJs $provide API internals & circular dependency problem.Yan Yankowski
The document provides an overview of AngularJS dependency injection and the $provide service. It explains the differences between providers, factories, services, values, constants, and decorators. It describes how $provide registers these items in the providerCache and instanceCache and instantiates them lazily through the $injector. Circular dependencies can cause errors since items point to each other before being fully instantiated.
The document discusses dependency injection (DI) using Dagger 2 in Java. It begins by showing an example of traditional Java code without DI and the issues it can cause. It then introduces DI and how Dagger 2 implements it using annotations and compile-time validation. Key features of Dagger 2 highlighted include its Android compatibility, JSR-330 support, and generated code for easy debugging. The document provides examples of Dagger 2 annotations and APIs for declaring modules, components, scopes, lazy injection, and qualifiers. Overall it serves as an introduction to dependency injection using Dagger 2 in Java applications.
This document provides information about the role of a computer support specialist. It describes that a computer support specialist repairs and maintains computers and servers, installing software and hardware. A degree is required, such as an associate's degree in computers. Typical duties include answering phone calls for technical support, troubleshooting problems onsite, and providing advice to users. Computer support specialists typically work 40 hours a week during daytime hours in well-lit offices, though overtime may occasionally be required. Salaries range from $30,000 to $77,000 depending on experience and qualifications. The field is growing as technology use increases in industries.
An alternative fuel company installs propane fuel systems on diesel engines to provide benefits to commercial customers. Their system involves a propane booster kit that is ASME and DOT approved to safely supply propane fuel. Tests show the system increases horsepower by 10%, fuel economy by 10-15%, and reduces fuel costs by 12% compared to diesel alone. Customers may also qualify for a federal tax credit of $0.50 per gallon of propane used.
The document discusses frontend frameworks for Rails 6, comparing the asset pipeline and webpack. It covers problems with the asset pipeline like slowness and lack of ES6 support. Webpack solves these issues through its module bundler capabilities and loaders/plugins. Stimulus.js is presented as a simple option to manage state in the browser via data attributes. React with Redux is discussed as another option but challenges mixing their state with Rails are noted. Integrating frameworks like React, Angular, Vue, Stimulus and Svelte with Rails via Webpacker is mentioned. Examples of React/Redux and Stimulus usage are provided.
For years i wanted a robust solution to organize code:
Eliminate messy code
Organize structure
Set strict rules for apps
Write simple tests that cover exactly what i need
Write Less, Think Less - Do More
I just wanted a simple hands-on philosophy in my code.
Then came NgRx/store.
This is an intro to ngrx/store and its echo-system with a usecase of Echoes Player (ng2) open source player developed with angular 2 and ngrx/store.
This document provides an overview of Java Server Pages (JSP) technology. It discusses JSP architecture and components like expressions, scriptlets, declarations, comments, directives, standard actions, implicit objects, and JavaBeans. Expression Language (EL) is also introduced, which allows accessing Java objects in JSP using a simpler syntax. Key elements like scopes, operators, and implicit objects available in EL are explained.
This 50 minutes talk covers the novelties of Java EE 7 (easier to understand if you already know Java EE 6). It comes from the talk I gave with Arun Gupta at JavaOne 2013
Simplified Android Development with Simple-StackGabor Varadi
This talk describes multiple Activities, Jetpack Navigation, and Simple-Stack in a single-activity android application context. How to develop screens and navigation using Simple-Stack.
В презентации описаны лучшие практики использования библиотеки React в связке с Redux. Быстрое разворачивание SPA без настройки Webpack и Babel с помощью утилиты Create React App, Smart and Dumb, Stateful and Stateless Components, управление рендером с помощью shouldComponentUpdate, Redux модули, мемоизация и middlewares.
More useful info on our:
- website: https://clickky.biz
- blog: https://clickky.biz/blog
Sign up!
Redux - idealne dopełnienie Reacta. Prezentacja przedstawiona na warsztatach z podstaw technologii Redux w ramach DreamLab Academy.
W razie pytań zapraszamy do kontaktu academy@dreamlab.pl
The presentation has been part of DreamLab Academy workshop on Redux. For more details get in touch - academy@dreamlab.pl
The document discusses building native components and modules for React Native applications. It provides guidance on creating native modules and components for both iOS and Android platforms. For native modules, it describes how to expose methods and properties to JavaScript. For native components, it explains how to create custom native views and expose their properties and events to React components.
This document provides an introduction to React for developers. It explains that React is a JavaScript library for building user interfaces developed by Facebook. It then covers key React concepts like components, props, state, rendering, and the virtual DOM. It also discusses tools and patterns for architecting React apps like Flux, Redux, routing, internationalization, and async logic. Finally, it recommends designing state carefully, using standards like Flux Standard Action, avoiding side effects in reducers, and leveraging tools like React DevTools.
Leveraging Completable Futures to handle your query results AsynchrhonouslyDavid Gómez García
The document discusses leveraging CompletableFutures to handle asynchronous query results in Java. It begins with an overview of concurrency vs parallelism and tools in Java for concurrency. It then covers using ExecutorServices and Futures to run tasks asynchronously before introducing CompletableFutures, which allow fluent chaining and composition of dependent asynchronous tasks. Examples are provided of using CompletableFutures to run database queries asynchronously and maximize performance. Considerations for using CompletableFutures in APIs are also discussed.
Architecting Single Activity Applications (With or Without Fragments)Gabor Varadi
Presentation by Gabor Varadi (@zhuinden)
What Activity and Fragment actually are in Android
What are the problems they solve, and what are their downsides
How to use a custom solution that simplifies navigation in Android applications
https://github.com/Zhuinden/navigation-example
Quick introduction into react and flux followed by a comparison of redux and alt flux frameworks and a simple hello world application implemented in each of them. Last two slides present a microservices approach to client side applications as one of approaches how to make transitions between frameworks easier.
Value types are at the core of Swift (seriously, mostly everything in the Swift standard library is a value type). But how do you avoid subclassing? That’s where the power of Protocol-Oriented programming comes in. Learn how to structure your code to never subclass (almost) again! Practical everyday examples and ideas for your own code base will be included.
This document discusses Spring MVC annotations used in controller classes. The @Controller annotation marks a class as a controller. The @RequestMapping annotation maps requests to controller methods. @PathVariable binds path variables to method parameters. @RequestParam binds query parameters. @RequestBody and @ResponseBody bind request/response bodies. Supported method argument and return types are also described.
The document provides an overview of state management in Angular using NgRx. It discusses setting up the store and reducers, accessing state in components, using selectors, handling asynchronous operations with effects, improving data persistence with NX, and connecting related data models. The key steps covered include creating interfaces and initial state, setting up the reducer, importing modules, dispatching actions, using entity adapters for collections, and composing selectors.
AngularJs $provide API internals & circular dependency problem.Yan Yankowski
The document provides an overview of AngularJS dependency injection and the $provide service. It explains the differences between providers, factories, services, values, constants, and decorators. It describes how $provide registers these items in the providerCache and instanceCache and instantiates them lazily through the $injector. Circular dependencies can cause errors since items point to each other before being fully instantiated.
The document discusses dependency injection (DI) using Dagger 2 in Java. It begins by showing an example of traditional Java code without DI and the issues it can cause. It then introduces DI and how Dagger 2 implements it using annotations and compile-time validation. Key features of Dagger 2 highlighted include its Android compatibility, JSR-330 support, and generated code for easy debugging. The document provides examples of Dagger 2 annotations and APIs for declaring modules, components, scopes, lazy injection, and qualifiers. Overall it serves as an introduction to dependency injection using Dagger 2 in Java applications.
This document provides information about the role of a computer support specialist. It describes that a computer support specialist repairs and maintains computers and servers, installing software and hardware. A degree is required, such as an associate's degree in computers. Typical duties include answering phone calls for technical support, troubleshooting problems onsite, and providing advice to users. Computer support specialists typically work 40 hours a week during daytime hours in well-lit offices, though overtime may occasionally be required. Salaries range from $30,000 to $77,000 depending on experience and qualifications. The field is growing as technology use increases in industries.
An alternative fuel company installs propane fuel systems on diesel engines to provide benefits to commercial customers. Their system involves a propane booster kit that is ASME and DOT approved to safely supply propane fuel. Tests show the system increases horsepower by 10%, fuel economy by 10-15%, and reduces fuel costs by 12% compared to diesel alone. Customers may also qualify for a federal tax credit of $0.50 per gallon of propane used.
The document provides information about the eight cultural regions of Native Americans:
1. The Northwest Coast region's tribes used cedar for canoes, housing, and tools and relied on salmon and seafood.
2. California tribes used acorns and tools made from materials like antlers, living in cone-shaped bark houses.
3. Great Basin tribes were nomadic hunter-gatherers adapted to desert conditions, using temporary willow shelters.
4. Plateau tribes lived near rivers, constructing partly underground homes from wood and reeds.
5. Great Plains tribes centered around buffalo, using its products like tendon for bows and hides for clothing and tipis.
6. Southwestern tribes far
Kevin is a 26-year-old Englishman who has lived in Beijing for 4 years. He grew up near Rochdale, England and studied Physics at Birmingham University. After graduating with his Master's degree, he moved to China because his girlfriend (now wife) is from Beijing. Kevin now works for NHN China on projects including nciku. In his free time, he enjoys geeky hobbies like computers, programming, science fiction and walking in the countryside.
1. Spring MVC is the web framework module of the Spring Framework, providing MVC architecture support and web request handling capabilities.
2. The DispatcherServlet is central to Spring MVC and handles incoming web requests, passing them to controllers for processing and returning a model and view.
3. Controllers handle requests and return a model and view, with the view resolver determining how to render the view. Annotations allow specifying request mappings and other configurations.
This document discusses microservices architectures and provides examples of tools used in microservices architectures like those implemented at Netflix. It describes common microservices patterns like service discovery (Eureka), configuration management (Archaius), load balancing (Ribbon), circuit breaking (Hystrix), monitoring (Turbine), edge services (Zuul), and logging (Blitz4j). It also discusses using these tools with Spring Cloud and provides code samples for configuring services using Netflix OSS and Spring Cloud.
This document provides an overview of REST (Representational State Transfer), including the key aspects of RESTful architectures such as:
- Resources are addressed through URIs
- Standard HTTP methods like GET, PUT, POST, DELETE are used to manipulate resources
- Data is represented in various formats like JSON, XML, HTML
- Communication is stateless between client and server
It then discusses how these REST principles are implemented in RESTEasy, the JBoss RESTful Web Services framework, through annotations and APIs. Features like content negotiation, interceptors, asynchronous calls and caching are also covered.
RESTEasy is a framework for building RESTful web services in Java. It allows developers to write JAX-RS annotated Java classes to define resources and their representations. Resources are addressable via URIs and support standard HTTP methods like GET, PUT, POST, and DELETE. Resources return representations in formats like JSON, XML, and HTML. Communication is stateless and driven by hypermedia links between resources. RESTEasy supports features like interceptors, asynchronous jobs, caching, GZIP compression, and integration with Spring and other frameworks.
Retrofit is a library for Java and Android that allows making HTTP requests to REST APIs. It uses OkHttp for networking functions and can convert HTTP responses to Java objects using converters like Gson. To use Retrofit, add it and converter dependencies to the build file, create a Retrofit instance with the base URL and converter, define an interface for API requests, and call those methods to make asynchronous network requests that return response data.
Retrofit is REST API client for Java. It is developed by Square Inc. It uses OkHttp library for HTTP Request. It is a simple library that is used for network transaction.
Step By Step Guide For Buidling Simple Struts AppSyed Shahul
This document provides steps to build a simple Struts application, including creating forms, actions, configuration files, and JSP pages. The key steps are:
1. Set up the project directory structure and files like web.xml.
2. Define forms, actions, and mappings in struts-config.xml.
3. Create ActionForm classes to handle form fields and validation.
4. Write Action classes to process requests and select views.
5. Develop JSP pages to display forms and output using Struts tags.
6. Build, deploy and test the complete application.
Adding a modern twist to legacy web applicationsJeff Durta
Avoid misery of working with legacy code
We will see how you can add independent and isolated components to existing pages; pages that may be difficult to change
React and Flux allow you to make self-contained additions that handle their own data access/persistence
Apache Wicket is a Java web application framework that uses a component-based programming model to build web UIs, allowing developers to treat page elements like buttons and labels as objects and handle events like clicks. It aims to bridge the gap between desktop and web development by enabling an event-driven programming style and component hierarchy similar to Swing. Wicket pages are composed of reusable Java components that correspond to HTML elements, avoiding the impedance mismatch between Java and HTTP programming models.
Training: Day Four - Struts, Tiles, Renders and FacesArtur Ventura
This is the fourth in our four part training sessions introducing FenixEdu development for new collaborators.
In this last session, we introduce our two presentation frameworks present in fenix, Struts and Faces, the presentation plugin Tiles and our rendering library Renders
The document provides an overview of the Android infrastructure and development environment. It discusses:
- The layers of an Android application including presentation, application logic, and domain layers.
- Key aspects of the Android runtime including the Dalvik VM, app lifecycle, resources and context handling.
- Libraries that help with common tasks like compatibility, fragments, networking and dependency injection including the Android Support Library, ActionBarSherlock, Retrofit, Dagger and RoboGuice.
- Alternatives for data storage like SQLite and ORM libraries like ORMLite and GreenDAO.
- Options for testing Android apps using the DVM, JVM, Robotium and Robolectric.
The document provides an overview of the Android infrastructure and key concepts:
(1) It describes the layers of an Android application including the presentation layer, application logic layer, and domain layer.
(2) It explains important Android concepts such as the Android runtime environment, Dalvik virtual machine, application lifecycle and activities, and use of contexts.
(3) It discusses alternatives for common tasks like dependency injection with RoboGuice and Dagger, handling resources and views with ButterKnife and AndroidAnnotations, and accessing data with SQLite and ORMLite.
(4) It also briefly covers testing approaches on the DVM and JVM using AndroidTestCase, Robotium, and Robolectric
Java Web Programming [2/9] : Servlet BasicIMC Institute
This document provides an overview of servlets, including:
- Servlets extend the functionality of HTTP servers and allow for dynamic content generation.
- Servlets handle requests and responses more efficiently than CGI due to being server-independent and allowing for session management.
- The servlet lifecycle includes initialization, request handling, and destruction. Common methods are init(), service(), doGet(), doPost(), and destroy().
- Servlets extract information from HTTP requests and use this to generate and return HTTP responses by setting headers and writing response content.
Flask and Angular: An approach to build robust platformsAyush Sharma
AngularJS is a really powerful and extensible Javascript library that can be used for all number of applications. The team that up with Flask and you've got a great power and maintainability.
HTTP Whiteboard - OSGI Compendium 6.0 - How web apps should have been! - R Augemfrancis
OSGi Community Event 2014
Abstract:
The new HTTP Whiteboard API is a significant improvement over Http Service 1.2. In this talk we'll explore the uses and benefits of the new API and how that this should have been what java webapps were from the start.
JavaFX 8 est disponible depuis mars 2014 et apporte son lot de nouveautés. Gradle est en version 2 depuis juillet 2014. Deux technologies plus que prometteuses: JavaFX donne un coup de jeune au développement d’applications desktop en Java en apportant un navigateur web intégré, le support des WebSockets, de la 3D, et bien d’autres. Gradle est l’outil de d’automatisation de build à la mode, apportant de superbes possibilités par rapport rapport à maven, outil vieillissant, grâce à l’engouement de la communauté vis à vis de cet outil mais aussi par le fait de la technologie utilisée en son sein: groovy. Venez découvrir comment il est possible de réaliser rapidement une application à la mode en JavaFX avec un outil à la mode également. Bref venez à une session trendy.
Session highlighting and demonstrating approaches to common challenges in modern portlet development. Topics include AJAX in JSR-168 and JSR-286 portlets, CSS and Javascript toolkits, security, and optimization of front-end resources. This session was presented at the Jasig Spring 2010 conference in San Diego, CA by Jennifer Bourey.
This document provides an overview of key Android development concepts and techniques. It discusses fragments, the support library, dependency injection, image caching, threading and AsyncTask, notifications, supporting multiple screens, and optimizing ListView performance. The document also recommends several popular Android libraries and open source apps that demonstrate best practices.
Similar to A portlet-API based approach for application integration (20)
Programming Foundation Models with DSPy - Meetup SlidesZilliz
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
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.
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
GraphRAG for Life Science to increase LLM accuracyTomaz Bratanic
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
“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.
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.
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
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
Infrastructure Challenges in Scaling RAG with Custom AI modelsZilliz
Building Retrieval-Augmented Generation (RAG) systems with open-source and custom AI models is a complex task. This talk explores the challenges in productionizing RAG systems, including retrieval performance, response synthesis, and evaluation. We’ll discuss how to leverage open-source models like text embeddings, language models, and custom fine-tuned models to enhance RAG performance. Additionally, we’ll cover how BentoML can help orchestrate and scale these AI components efficiently, ensuring seamless deployment and management of RAG systems in the cloud.
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
3. 3
Application Integration
Application integration is a generic problem
§ Not CMS specific
§ Depending on specific application issues
In general huge range of options
§ Link, IFrame, “merged” content, integrated menu
§ Adapting the application may be possible. Needed effort???
4. 4
Discussed solution
Possible solution for
§ Seamless integration into Magnolia
§ Small, new applications
Portlet-API based approach offers:
§ Simple and flexible API
§ Dynamic flow over several pages
§ Different applications on the same page
§ Configuration in AdminCentral
7. 7
Portlet
§ JSR-168 (and JSR-286)
§ Standard for developing portal components with Java
§ Run in a Portlet Container / Portal Server
§ Action / render phase
§ Simple API
13. 13
Portlet API usage example
public class DemoPortlet implements Portlet
{
public void init(PortletConfig config) {
String myJspTemplate = config.getParameters().get("myJspTemplate");
}
public void processAction(ActionRequest request, ActionResponse response) {
String action = request.getAttribute(ActionRequest.ACTION_ATTRIBUTE_NAME);
if ("redirect".equals(action))
response.sendRedirect(request.getParameter("target"));
response.setRenderParameter("jsp", myJspTemplate);
}
public void render(RenderRequest request, RenderResponse response) {
Writer out = response.getWriter();
PortletURL url = response.createActionURL("new_action");
out.write("<a href="" + url.toString() + "">execute new_action</a>");
String jspTemplateName = (String) request.getAttribute("jsp");
((WebContext) MgnlContext.getInstance()).include(jspTemplateName, out);
}
public void destroy() { }
}
14. 14
Portlet API usage example
public class DemoPortlet implements Portlet
{
public void init(PortletConfig config) {
String myJspTemplate = config.getParameters().get("myJspTemplate");
}
public void processAction(ActionRequest request, ActionResponse response) {
String action = request.getAttribute(ActionRequest.ACTION_ATTRIBUTE_NAME);
if ("redirect".equals(action))
response.sendRedirect(request.getParameter("target"));
response.setRenderParameter("jsp", myJspTemplate);
}
public void render(RenderRequest request, RenderResponse response) {
Writer out = response.getWriter();
PortletURL url = response.createActionURL("new_action");
out.write("<a href="" + url.toString() + "">execute new_action</a>");
String jspTemplateName = (String) request.getAttribute("jsp");
((WebContext) MgnlContext.getInstance()).include(jspTemplateName, out);
}
public void destroy() { }
}
15. 15
Portlet API usage example
public class DemoPortlet implements Portlet
{
public void init(PortletConfig config) {
String myJspTemplate = config.getParameters().get("myJspTemplate");
}
public void processAction(ActionRequest request, ActionResponse response) {
String action = request.getAttribute(ActionRequest.ACTION_ATTRIBUTE_NAME);
if ("redirect".equals(action))
response.sendRedirect(request.getParameter("target"));
response.setRenderParameter("jsp", myJspTemplate);
}
public void render(RenderRequest request, RenderResponse response) {
Writer out = response.getWriter();
PortletURL url = response.createActionURL("new_action");
out.write("<a href="" + url.toString() + "">execute new_action</a>");
String jspTemplateName = (String) request.getAttribute("jsp");
((WebContext) MgnlContext.getInstance()).include(jspTemplateName, out);
}
public void destroy() { }
}
16. 16
createActionURL
Creates a link to the active portlet on the current
page with specified action
§ Use the original URI of the current request as target address
§ Set “action” and “portletId” parameters
§ Add all (other) parameters of the current request
17. 17
API extensions
ActionResponse {
HttpServletResponse handleResponseMyself();
}
§ Portlet must (and can!) do any further request handling
itself
§ “Generalization” of the redirect concept
18. 18
Reply caching
§ Not every page load has an “action” and “render” phase!
Example: Page with a shopping cart and a weather forecast
§ Remove one item of the shopping cart
§ Change the displayed location in the weather gadget
à the last shopping cart action is “invalid”
Caching the RenderRequests for every portlet on the page
allows independent portlet behaviour!
A basic principle in the portlet context
19. 19
Implementation details
ActionRequestImpl:
§ Special handling for action and uuid
§ Needs access to HttpServletRequest
ActionResponseImpl:
§ Needs access to HttpServletResponse
§ Store redirect location if called
RenderRequestImpl:
§ Needs ActionResponse in constructor
RenderResponseImpl:
§ Needs HttpServletRequest and Writer in constructor
§ createActionURL(…)
20. 20
Implementation details (2)
PortletURLImpl:
§ “Merge” parameters and action/portletId and create
parameter string
PortletConfig:
§ Bean to provide the configuration (content2bean)
§ classname
§ portletId
§ Description
§ Map<String, String> parameters
21. 21
Keeping the RenderRequest
§ Put portlet id, portlet object and RenderRequest in a
container
§ Store container in session
§ G container is page-specific
On a request:
§ Check for action command à do it!
§ store in new container in session
§ Check for stored container entry
§ move to new container and keep in session
§ render it later during rendering
§ Call default action for missing entries and store them
§ Remove old container
22. 22
Default action
Provide a default action per portlet and page
§ Place the same portlet on different pages with different
functionality (i.e. login, logout, display data, edit data, …)
§ Simple and intuitive menu integration
§ Configure the default action on the page
§ Allows one portlet per application
(in principle, different portlets could share the same data /
state)
§ Transparent for the portlet!
23. 23
Integration into Magnolia
Action phase:
§ Add a portlet filter
§ Alternative: action phase in template’s model (Mgnl 4.x)
(in the paragraph’s model it’s already too late)
Render phase:
§ Called while rendering the paragraph containing the portlet
24. 24
PortletFilter
Get all portlets Call
Get action
of current page processAction
yes Get default
action
Redirect? yes
Portlets Have
yes no
found? action? no
no
Have
Store in new
no yes container yes
container
entry?
Remove old More
no
container portlets?
25. 25
Render a portlet
§ JSP or Freemarker-template with only one tag:
<mgnlportlet:portlet/>
(integrated in Magnolia as paragraph)
§ Tag implementation:
§ get portletId out of current content node
§ get portlet object and render request out of container
§ call portlet.render(…)
31. 31
Putting all together: seamless Magnolia integration
applicational pages
h
r a g ra p
te xt pa
para graph
portlet
CMS (only) pages
32. 32
Unaddressed issues
§ Caching
§ Deployment
§ Several applications on same page may conflict (due to
redirects)
à how should the applications behave?
§ Integration of 3rd party frameworks
33. 33
Real world experiences
§ Used in production
§ Several applications integrated and live:
§ virtual portfolio system
§ serving personalized content (account information)
§ CSV download of table content
(render into a CSV file instead of a HTML table)
§ form editor (for Magnolia 3.5 / 3.6)
§ wizards
34. 34
Real world experiences (2)
§ Well-suited for small applications
§ Multi-page setup is fragile
§ Additional configuration inside the paragraph possible
§ Use “normal” CMS page for additional content (help, …)
§ Mixing of portlet-paragraphs and normal paragraphs on
same page possible
35. 35
Findings
Intuitive and flexible
Simple API (no specific framework to use)
Proper model phase support
Fusing with Magnolia (menu, mix paragraphs, …)
Few programmer support
Configuration dependencies (links to other pages)
Complexity of bigger applications