The document discusses a portlet bridge, which allows popular MVC frameworks like JSF to be used in a portal by translating requests and responses between the portlet and MVC environments. It specifically describes the JBoss Portlet Bridge, which connects the portlet container and JSF runtime, allowing JSF resources to satisfy portlet requests while supporting both JSF and Java portlet specifications. The presentation covers portals, portlets, the differences between portlets and servlets, and how the portlet bridge provides an abstraction layer so that portlets can be developed using JSF without understanding low-level portlet concepts.
Portlets 2.0 Next Generation Portlet Applications
This document discusses portlets and the JSR 286 specification. It summarizes the key concepts of portlets, how they have evolved from JSR 168 to support inter-portlet communication and new features like resource serving. It also provides demos of public render parameters, events, and portlet federation capabilities.
The document discusses the Portlet 2.0 JSR 286 specification and outlines some of the key new features it introduces over JSR 168, including the ability for portlets to communicate with each other through shared render parameters and events. It also covers additional capabilities like portlets being able to generate non-markup content through resource serving and better support for web frameworks and AJAX. The presentation provides an overview of portlet concepts and the limitations of JSR 168 that JSR 286 aims to address.
JSR 286 (Portlets 2.0) aims to address limitations of JSR 168 by allowing portlets to communicate and share state. It introduces mechanisms like public render parameters, portlet events, and resource serving to enable interportlet coordination. These new capabilities help portlets integrate better with web frameworks and the overall portal architecture.
FIWARE Wednesday Webinars - How to Secure FIWARE ArchitecturesFIWARE
How to Secure FIWARE Architectures - 10th April 2019
Corresponding webinar recording: http://bit.ly/2UsvtzZ
Introduction to basic Identity Management and Security within the FIWARE Catalogue. How to secure your microservices within a Smart Solution.
Chapter: Security
Difficulty: 1
Audience: Any Technical
Presenter: Jason Fox (Senior Technical Evangelist, FIWARE Foundation)
FIWARE Wednesday Webinars - Strategies for Context Data PersistenceFIWARE
Strategies for Context Data Persistence Webinar - 25th March 2020
Corresponding webinar recording: https://youtu.be/_uLZDGFPlRA
Introduction to the data persistence components found within the FIWARE Catalogue and various options on how to maintain a historical record of context when a context broker has no memory.
Chapter: Core Context
Difficulty: 3
Audience: Any Technical
Presenter: Jason Fox (Senior Technical Evangelist, FIWARE Foundation)
FIWARE Wednesday Webinars - How to Secure IoT DevicesFIWARE
FIWARE Wednesday Webinar - How to Secure IoT Devices (22nd April 2020)
Corresponding webinar recording: https://youtu.be/_87IZhrYo3U
Live coding session and commentary, demonstrating various techniques and methods for securing the interactions between Devices, IoT Agents and the Context Broker
Chapter: Security
Difficulty: 3
Audience: Any Technical
Presenter: Jason Fox (Senior Technical Evangelist, FIWARE Foundation)
The document discusses a portlet bridge, which allows popular MVC frameworks like JSF to be used in a portal by translating requests and responses between the portlet and MVC environments. It specifically describes the JBoss Portlet Bridge, which connects the portlet container and JSF runtime, allowing JSF resources to satisfy portlet requests while supporting both JSF and Java portlet specifications. The presentation covers portals, portlets, the differences between portlets and servlets, and how the portlet bridge provides an abstraction layer so that portlets can be developed using JSF without understanding low-level portlet concepts.
Portlets 2.0 Next Generation Portlet Applications
This document discusses portlets and the JSR 286 specification. It summarizes the key concepts of portlets, how they have evolved from JSR 168 to support inter-portlet communication and new features like resource serving. It also provides demos of public render parameters, events, and portlet federation capabilities.
The document discusses the Portlet 2.0 JSR 286 specification and outlines some of the key new features it introduces over JSR 168, including the ability for portlets to communicate with each other through shared render parameters and events. It also covers additional capabilities like portlets being able to generate non-markup content through resource serving and better support for web frameworks and AJAX. The presentation provides an overview of portlet concepts and the limitations of JSR 168 that JSR 286 aims to address.
JSR 286 (Portlets 2.0) aims to address limitations of JSR 168 by allowing portlets to communicate and share state. It introduces mechanisms like public render parameters, portlet events, and resource serving to enable interportlet coordination. These new capabilities help portlets integrate better with web frameworks and the overall portal architecture.
FIWARE Wednesday Webinars - How to Secure FIWARE ArchitecturesFIWARE
How to Secure FIWARE Architectures - 10th April 2019
Corresponding webinar recording: http://bit.ly/2UsvtzZ
Introduction to basic Identity Management and Security within the FIWARE Catalogue. How to secure your microservices within a Smart Solution.
Chapter: Security
Difficulty: 1
Audience: Any Technical
Presenter: Jason Fox (Senior Technical Evangelist, FIWARE Foundation)
FIWARE Wednesday Webinars - Strategies for Context Data PersistenceFIWARE
Strategies for Context Data Persistence Webinar - 25th March 2020
Corresponding webinar recording: https://youtu.be/_uLZDGFPlRA
Introduction to the data persistence components found within the FIWARE Catalogue and various options on how to maintain a historical record of context when a context broker has no memory.
Chapter: Core Context
Difficulty: 3
Audience: Any Technical
Presenter: Jason Fox (Senior Technical Evangelist, FIWARE Foundation)
FIWARE Wednesday Webinars - How to Secure IoT DevicesFIWARE
FIWARE Wednesday Webinar - How to Secure IoT Devices (22nd April 2020)
Corresponding webinar recording: https://youtu.be/_87IZhrYo3U
Live coding session and commentary, demonstrating various techniques and methods for securing the interactions between Devices, IoT Agents and the Context Broker
Chapter: Security
Difficulty: 3
Audience: Any Technical
Presenter: Jason Fox (Senior Technical Evangelist, FIWARE Foundation)
This presentation, given at the Alpes JUG in Grenoble France, talks about how to go from portlet development to composite applications development. Composite applications are a great way to speed up web application development.
WebSphere Portal V6.1 provides a technical overview of the product's architecture and components. It discusses the portal tier, backend tier, security tier, content tier and how they work together. It also summarizes the main components of WebSphere Portal including the application server, database, directory server, and search. Finally, it highlights how WebSphere Portal works with various platforms, databases, directories, security managers, web servers and browsers.
A portal is a unified web-based interface that aggregates content and applications from diverse sources and provides single sign-on access. Portals offer benefits like customization, personalization, integration and organization to both users and companies. Portlets are web components that generate dynamic content and are managed within a portlet container. The Java Portlet Specification JSR 168 standardizes portlet development.
This document provides an introduction to Java standard portlets. It begins by discussing the limitations of traditional servlet and JSP architectures. It then introduces portals and defines portlets as pluggable user interface components that can be aggregated and displayed within a portal. The document outlines the portlet lifecycle and details the request and response processing. It also discusses portlet modes, window states, filters, and inter-portlet communication. Key advantages of using portlets over traditional web applications are highlighted.
Introduction to Portlets using Liferay Portal (Part 2)rivetlogic
The document discusses portlet resource serving in Liferay Portal using the Java Portlet Specification 2.0 (JSR 286). It provides an example of creating a JSP-based portlet that returns dynamic content via Ajax calls using the serveResource method. The portlet is configured to support resource serving and an Ajax script is included to make requests to the resource URL and display the response. Resource serving allows portlets to directly serve resources, interact via Ajax, and have access to portlet context and state information, addressing limitations of prior specifications.
Introduction to Portlets Using Liferay Portalrivetlogic
Rivet Logic's Costa Rica Developer's Forge presented this at a Costa Rica Java Users Group meeting. The presentation provides an introduction to portlets using Liferay Portal - including Portals and Portlets; Liferay Portal 6.0, Liferay SDK and Liferay IDE; Portlet 1.0 (JSR 168).
This document summarizes a presentation about harnessing JSR-168 portlets. It discusses the portlet specification and container, including the portlet interface and lifecycle methods. It emphasizes separating action and rendering logic. The presentation also discusses sharing assets and data across portlets to improve integration.
This document provides an overview of web application development using portlets. It introduces application servers, portlets, and the Liferay portal framework. Key points covered include the portlet lifecycle and interfaces, deploying portlets using tools like Ant and the Liferay Plugin SDK, and hosting portlets on an application server like Glassfish. The goal is to provide tutorial on developing portlets for science gateways.
This document provides an overview of portals in Oracle Application Development Framework (ADF) and WebCenter. It discusses portlets, including what they are, different types of portlets, and how to develop and deploy portlets. It also covers consuming portlets in WebCenter Portal and Spaces, as well as portlet communication. The learning objectives are outlined and steps for including a portlet on an application page are provided. Guidelines for portlet development and tips are also included.
D22 Portlet Development With Open Source FrameworksSunil Patil
The document discusses various frameworks that can be used for portlet development, including the Struts Portlet Framework and Spring 2.0. It provides an overview of the Struts Portlet Framework, describing its runtime components and tooling support. It also summarizes key concepts in Struts 2.0 like actions, interceptors, and the value stack. The document recommends frameworks like JSF and Struts 2.0 for new portlet development and considers factors like skills availability and complexity.
D22 portlet development with open source frameworksSunil Patil
The document discusses various frameworks for portlet development including Struts, Spring, and JSF. It provides details on the Struts Portlet Framework and Struts 2.0 framework, including their key components, architecture, and how they can be used to build portlet applications.
This document provides an introduction to application servers, web applications, and portlets. It describes how application servers provide a framework for hosting web applications. Web applications can offer many services and are accessed over a network through a web browser. Portlets are web components that make up parts of web pages and allow users to interact with custom applications in a portlet container like Liferay. The document reviews common application servers and provides details on developing portlets for use in a portal framework.
Portlets allow for aggregation and personalization of web content from different sources. Portlets produce fragments of markup that are combined into a portal page. A portlet container runs and manages the lifecycles of portlets. Portlets have request processing phases and modes that determine the functions and content they provide.
This document discusses reducing JavaScript usage for backend developers by exploring web components, Polymer, and JavaServer Faces (JSF). It provides an overview of web components goals and standards, introduces Polymer and how it builds on web components, discusses JSF and the PrimeFaces component library, and demos how to use Polymer and PrimeFaces. The goals of web components, Polymer, and PrimeFaces are to reduce code, improve readability and reusability through composable elements. Browser support for the various web component specifications is outlined.
Apache Shindig is an open source gadget container that allows developers to easily write reusable web applications using HTML, CSS and JavaScript. It supports the Google Gadgets specification and OpenSocial specification, allowing gadgets to be embedded into various contexts like websites and portals. The authors used Apache Shindig to power their portal server, bundling it using OSGi and enabling features like caching to improve performance. They were able to build a comprehensive portal with open standards and a gadget repository browser.
This document discusses enterprise portals, which are frameworks for integrating information, people, and processes on intranets and websites. It describes popular portal vendors and technologies, the components of portals like portlets, and both the common functionality of portals and some common shortcomings related to security. It then discusses techniques for breaking out of custom applications on portals to access the full portal framework and ways to abuse portlet functionality for activities like port scanning and accessing protected resources on internal networks.
Presentation by Ian de Villiers at ZaCon 1 in 2009.
The presentation begins by naming a few enterprise portal vendors followed by a brief overview of enterprise portals. Common shortcomings of EP's are discussed, which leads on to discussions about using custom applications to expose the full functionality of a portal.
This document provides an overview of BeeGo, an open source web framework for Go (Golang). It discusses some of BeeGo's key features like its MVC architecture, annotation router, auto API documentation, and CLI tool for rapid development. It also summarizes BeeGo's request lifecycle handling, separation of request infrastructure from business logic, and modules for sessions, caching, logging, HTTP client, and ORM.
Exploring the latest and greatest from Java 14Miro Cupak
Miro Cupak presented at the J4K 2020 conference on exploring the latest features in Java 14, including new productivity language features like switch expressions and text blocks as well as new APIs like flight recorder and foreign memory access. He discussed upcoming features and then provided a live coding demonstration.
Miro Cupak gave a presentation on exploring reactive programming in Java, discussing 9 levels of reactive programming supported in Java, from basic threading in Java 1+ to fully reactive microservices using libraries like Vert.x, Spring WebFlux, and Kafka. The presentation covered live coding examples and discussed the different levels from low-level threading to high-level reactive libraries and services.
This presentation, given at the Alpes JUG in Grenoble France, talks about how to go from portlet development to composite applications development. Composite applications are a great way to speed up web application development.
WebSphere Portal V6.1 provides a technical overview of the product's architecture and components. It discusses the portal tier, backend tier, security tier, content tier and how they work together. It also summarizes the main components of WebSphere Portal including the application server, database, directory server, and search. Finally, it highlights how WebSphere Portal works with various platforms, databases, directories, security managers, web servers and browsers.
A portal is a unified web-based interface that aggregates content and applications from diverse sources and provides single sign-on access. Portals offer benefits like customization, personalization, integration and organization to both users and companies. Portlets are web components that generate dynamic content and are managed within a portlet container. The Java Portlet Specification JSR 168 standardizes portlet development.
This document provides an introduction to Java standard portlets. It begins by discussing the limitations of traditional servlet and JSP architectures. It then introduces portals and defines portlets as pluggable user interface components that can be aggregated and displayed within a portal. The document outlines the portlet lifecycle and details the request and response processing. It also discusses portlet modes, window states, filters, and inter-portlet communication. Key advantages of using portlets over traditional web applications are highlighted.
Introduction to Portlets using Liferay Portal (Part 2)rivetlogic
The document discusses portlet resource serving in Liferay Portal using the Java Portlet Specification 2.0 (JSR 286). It provides an example of creating a JSP-based portlet that returns dynamic content via Ajax calls using the serveResource method. The portlet is configured to support resource serving and an Ajax script is included to make requests to the resource URL and display the response. Resource serving allows portlets to directly serve resources, interact via Ajax, and have access to portlet context and state information, addressing limitations of prior specifications.
Introduction to Portlets Using Liferay Portalrivetlogic
Rivet Logic's Costa Rica Developer's Forge presented this at a Costa Rica Java Users Group meeting. The presentation provides an introduction to portlets using Liferay Portal - including Portals and Portlets; Liferay Portal 6.0, Liferay SDK and Liferay IDE; Portlet 1.0 (JSR 168).
This document summarizes a presentation about harnessing JSR-168 portlets. It discusses the portlet specification and container, including the portlet interface and lifecycle methods. It emphasizes separating action and rendering logic. The presentation also discusses sharing assets and data across portlets to improve integration.
This document provides an overview of web application development using portlets. It introduces application servers, portlets, and the Liferay portal framework. Key points covered include the portlet lifecycle and interfaces, deploying portlets using tools like Ant and the Liferay Plugin SDK, and hosting portlets on an application server like Glassfish. The goal is to provide tutorial on developing portlets for science gateways.
This document provides an overview of portals in Oracle Application Development Framework (ADF) and WebCenter. It discusses portlets, including what they are, different types of portlets, and how to develop and deploy portlets. It also covers consuming portlets in WebCenter Portal and Spaces, as well as portlet communication. The learning objectives are outlined and steps for including a portlet on an application page are provided. Guidelines for portlet development and tips are also included.
D22 Portlet Development With Open Source FrameworksSunil Patil
The document discusses various frameworks that can be used for portlet development, including the Struts Portlet Framework and Spring 2.0. It provides an overview of the Struts Portlet Framework, describing its runtime components and tooling support. It also summarizes key concepts in Struts 2.0 like actions, interceptors, and the value stack. The document recommends frameworks like JSF and Struts 2.0 for new portlet development and considers factors like skills availability and complexity.
D22 portlet development with open source frameworksSunil Patil
The document discusses various frameworks for portlet development including Struts, Spring, and JSF. It provides details on the Struts Portlet Framework and Struts 2.0 framework, including their key components, architecture, and how they can be used to build portlet applications.
This document provides an introduction to application servers, web applications, and portlets. It describes how application servers provide a framework for hosting web applications. Web applications can offer many services and are accessed over a network through a web browser. Portlets are web components that make up parts of web pages and allow users to interact with custom applications in a portlet container like Liferay. The document reviews common application servers and provides details on developing portlets for use in a portal framework.
Portlets allow for aggregation and personalization of web content from different sources. Portlets produce fragments of markup that are combined into a portal page. A portlet container runs and manages the lifecycles of portlets. Portlets have request processing phases and modes that determine the functions and content they provide.
This document discusses reducing JavaScript usage for backend developers by exploring web components, Polymer, and JavaServer Faces (JSF). It provides an overview of web components goals and standards, introduces Polymer and how it builds on web components, discusses JSF and the PrimeFaces component library, and demos how to use Polymer and PrimeFaces. The goals of web components, Polymer, and PrimeFaces are to reduce code, improve readability and reusability through composable elements. Browser support for the various web component specifications is outlined.
Apache Shindig is an open source gadget container that allows developers to easily write reusable web applications using HTML, CSS and JavaScript. It supports the Google Gadgets specification and OpenSocial specification, allowing gadgets to be embedded into various contexts like websites and portals. The authors used Apache Shindig to power their portal server, bundling it using OSGi and enabling features like caching to improve performance. They were able to build a comprehensive portal with open standards and a gadget repository browser.
This document discusses enterprise portals, which are frameworks for integrating information, people, and processes on intranets and websites. It describes popular portal vendors and technologies, the components of portals like portlets, and both the common functionality of portals and some common shortcomings related to security. It then discusses techniques for breaking out of custom applications on portals to access the full portal framework and ways to abuse portlet functionality for activities like port scanning and accessing protected resources on internal networks.
Presentation by Ian de Villiers at ZaCon 1 in 2009.
The presentation begins by naming a few enterprise portal vendors followed by a brief overview of enterprise portals. Common shortcomings of EP's are discussed, which leads on to discussions about using custom applications to expose the full functionality of a portal.
This document provides an overview of BeeGo, an open source web framework for Go (Golang). It discusses some of BeeGo's key features like its MVC architecture, annotation router, auto API documentation, and CLI tool for rapid development. It also summarizes BeeGo's request lifecycle handling, separation of request infrastructure from business logic, and modules for sessions, caching, logging, HTTP client, and ORM.
Exploring the latest and greatest from Java 14Miro Cupak
Miro Cupak presented at the J4K 2020 conference on exploring the latest features in Java 14, including new productivity language features like switch expressions and text blocks as well as new APIs like flight recorder and foreign memory access. He discussed upcoming features and then provided a live coding demonstration.
Miro Cupak gave a presentation on exploring reactive programming in Java, discussing 9 levels of reactive programming supported in Java, from basic threading in Java 1+ to fully reactive microservices using libraries like Vert.x, Spring WebFlux, and Kafka. The presentation covered live coding examples and discussed the different levels from low-level threading to high-level reactive libraries and services.
This document discusses recent and upcoming features in Java, including single-file source programs, improved HTTP/2 client API, productivity features like switch expressions and pattern matching, text blocks, records, and a new flight recorder API. The author will provide a live demo and take questions on exploring the last year of Java development.
Local variable type inference - Will it compile?Miro Cupak
This document discusses local variable type inference, asking whether code will compile without explicitly declaring variable types, and is authored by Miro Cupak, Co-founder and VP Engineering at DNAstack. The author invites questions on the topic of local variable type inference.
The Good, the Bad and the Ugly of Java API designMiro Cupak
The document discusses Java API design patterns and antipatterns based on several Java APIs, including:
1. Collections API - Take advantage of immutable collections created with factory methods and copies to avoid issues with shared references.
2. Stack-walking API - Leverage the Stream API to lazily access call stack elements and avoid manually resolving classes.
3. Process API - Use ProcessHandle for a clean way to obtain process information with convenience methods rather than external libraries.
4. HTTP client API - Prefer the new HTTP client over HttpURLConnection for a clear, versatile and flexible design with asynchronous support.
Local variable type inference - Will it compile?Miro Cupak
Local variable type inference in Java allows the compiler to infer the type of local variables declared with "var" instead of explicitly stating the type. While it reduces boilerplate and improves readability, it has some limitations and best practices should be followed when using it. Specifically, var cannot be used for declarations without initializers, null/array initializers, compound declarations, method signatures, class fields, catch formals, lambdas or method references. Developer needs to consider whether the inferred type will be obvious, be careful of primitive types being inferred as int, and avoid overuse with generics.
Miro Cupak explores 8 levels of reactive programming in Java, from the basic Thread and Runnable interfaces introduced in Java 1 to higher levels including reactive streams in Java 9, the HTTP/2 client in Java 11, and reactive libraries and microservices. The tweet thread outlines each level, noting the Java version it was introduced in, with the goal of explaining reactive programming concepts and discussing any questions.
The good, the bad, and the ugly of Java API designMiro Cupak
Miro Cupak discusses the good and bad aspects of several Java API designs, including Collections, Stack-walking, Process, and HTTP client APIs. Some best practices highlighted are convenience factory methods, immutability by default, lazy evaluation using streams, and clear separation of concepts. Antipatterns include unnecessary dependencies, unexpected behavior, and side effects. Well-designed APIs use static methods, fluent interfaces, and asynchronous programming with CompletableFuture.
This document contains the agenda and tasks for a workshop on modern Java features. The workshop will be held on October 30, 2019 from 9:15am to 6pm with a lunch break from 1:15pm to 2pm. It will cover 10 lessons including JShell, collections factory methods, try-with-resources improvements, Stream API enhancements, Optional extensions, CompletableFuture updates, and reactive streams. Each lesson contains multiple tasks for participants to complete to explore the featured Java topics hands-on.
Miro Cupak gave a presentation on exploring reactive programming in Java. He discussed 8 levels of reactivity in Java, ranging from basic threading concepts in early versions of Java to fully reactive microservices using libraries like Vert.x and frameworks like Spring WebFlux. The talk included a live demo and concluded with an opportunity for questions.
The good, the bad, and the ugly of Java API designMiro Cupak
The document discusses various Java API design patterns and antipatterns related to collections, stack walking, process handling, and HTTP clients. Some best practices highlighted include using immutable collections by default, leveraging streams, providing convenience methods, and having a clear separation of concepts. Antipatterns include unnecessary dependencies, unexpected behavior, and inconsistent naming. The document advocates preferring functionality in the JDK over external libraries.
This document summarizes new features in modern Java including private methods in interfaces, improved try-with-resources, switch expressions, and local variable type inference. It provides examples and best practices for each feature, such as using private methods to keep default methods short and clear, always preferring try-with-resources over try-finally, and being careful when combining local variable type inference with generics. The document aims to help developers write cleaner code with the new Java features.
The good, the bad, and the ugly of Java API designMiro Cupak
The document discusses the good and bad aspects of Java API design based on the Collections API, Stack-walking API, Process API, and HTTP client API. Some best practices highlighted include using immutable collections by default, static factory methods to create objects, and convenience methods. Antipatterns include obtaining collections through other data structures and manually resolving classes. Patterns referenced are lazy access via streams and providing adapters between related types.
This document contains the schedule and lessons for a workshop on modern Java features. The schedule includes registration, two workshop sessions with a lunch break in between. The lessons cover JShell, collection factory methods, try-with-resources improvements, Stream API enhancements, Optional extensions, CompletableFuture updates, reactive streams, and more. The document provides tasks for participants to complete to learn each lesson.
Miro Cupak presented on exploring reactive programming in Java, demonstrating different levels of reactivity available in Java from threads and runnables to reactive streams and libraries to fully reactive microservices. The presentation covered 8 levels of reactive programming capabilities in Java from the earliest versions to the newest, including executors, fork/join pools, completable futures, reactive streams, HTTP/2 clients, and reactive libraries and frameworks. Cupak concluded by taking questions on Twitter.
This document discusses writing clean code with modern Java features such as immutable collections, private methods in interfaces, switch expressions, and local variable type inference. It provides tips for using each feature, such as preferring immutable collections by default and only adding mutability when needed, using private methods in interfaces to keep default methods short, and using local variable type inference carefully and only for variables with explicit initializers. The document encourages writing clean, readable code with these new Java language features.
Exploring what's new in Java 10 and 11 (and 12)Miro Cupak
This document is a presentation on new features in recent and upcoming versions of Java, including Java 10, 11, and 12. It includes a live demo section and leaves time at the end for questions. The session notes will be shared on Twitter.
This document is a summary of a presentation on new features in Java 10 and 11. It includes the presenter's Twitter handle, an invitation to a live demo during the presentation, and a request for questions from the audience with an assigned hashtag. The session notes from the presentation will be shared on Twitter.
This Twitter thread from Miro Cupak discusses what's new in Java in 2018. It includes a live demo as well as an invitation for questions from attendees. Additional session notes were provided on Twitter.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
Hand Rolled Applicative User ValidationCode KataPhilip Schwarz
Could you use a simple piece of Scala validation code (granted, a very simplistic one too!) that you can rewrite, now and again, to refresh your basic understanding of Applicative operators <*>, <*, *>?
The goal is not to write perfect code showcasing validation, but rather, to provide a small, rough-and ready exercise to reinforce your muscle-memory.
Despite its grandiose-sounding title, this deck consists of just three slides showing the Scala 3 code to be rewritten whenever the details of the operators begin to fade away.
The code is my rough and ready translation of a Haskell user-validation program found in a book called Finding Success (and Failure) in Haskell - Fall in love with applicative functors.
14 th Edition of International conference on computer visionShulagnaSarkar2
About the event
14th Edition of International conference on computer vision
Computer conferences organized by ScienceFather group. ScienceFather takes the privilege to invite speakers participants students delegates and exhibitors from across the globe to its International Conference on computer conferences to be held in the Various Beautiful cites of the world. computer conferences are a discussion of common Inventions-related issues and additionally trade information share proof thoughts and insight into advanced developments in the science inventions service system. New technology may create many materials and devices with a vast range of applications such as in Science medicine electronics biomaterials energy production and consumer products.
Nomination are Open!! Don't Miss it
Visit: computer.scifat.com
Award Nomination: https://x-i.me/ishnom
Conference Submission: https://x-i.me/anicon
For Enquiry: Computer@scifat.com
Liberarsi dai framework con i Web Component.pptxMassimo Artizzu
In Italian
Presentazione sulle feature e l'utilizzo dei Web Component nell sviluppo di pagine e applicazioni web. Racconto delle ragioni storiche dell'avvento dei Web Component. Evidenziazione dei vantaggi e delle sfide poste, indicazione delle best practices, con particolare accento sulla possibilità di usare web component per facilitare la migrazione delle proprie applicazioni verso nuovi stack tecnologici.
Flutter is a popular open source, cross-platform framework developed by Google. In this webinar we'll explore Flutter and its architecture, delve into the Flutter Embedder and Flutter’s Dart language, discover how to leverage Flutter for embedded device development, learn about Automotive Grade Linux (AGL) and its consortium and understand the rationale behind AGL's choice of Flutter for next-gen IVI systems. Don’t miss this opportunity to discover whether Flutter is right for your project.
E-Invoicing Implementation: A Step-by-Step Guide for Saudi Arabian CompaniesQuickdice ERP
Explore the seamless transition to e-invoicing with this comprehensive guide tailored for Saudi Arabian businesses. Navigate the process effortlessly with step-by-step instructions designed to streamline implementation and enhance efficiency.
Malibou Pitch Deck For Its €3M Seed Roundsjcobrien
French start-up Malibou raised a €3 million Seed Round to develop its payroll and human resources
management platform for VSEs and SMEs. The financing round was led by investors Breega, Y Combinator, and FCVC.
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
Preparing Non - Technical Founders for Engaging a Tech AgencyISH Technologies
Preparing non-technical founders before engaging a tech agency is crucial for the success of their projects. It starts with clearly defining their vision and goals, conducting thorough market research, and gaining a basic understanding of relevant technologies. Setting realistic expectations and preparing a detailed project brief are essential steps. Founders should select a tech agency with a proven track record and establish clear communication channels. Additionally, addressing legal and contractual considerations and planning for post-launch support are vital to ensure a smooth and successful collaboration. This preparation empowers non-technical founders to effectively communicate their needs and work seamlessly with their chosen tech agency.Visit our site to get more details about this. Contact us today www.ishtechnologies.com.au
UI5con 2024 - Bring Your Own Design SystemPeter Muessig
How do you combine the OpenUI5/SAPUI5 programming model with a design system that makes its controls available as Web Components? Since OpenUI5/SAPUI5 1.120, the framework supports the integration of any Web Components. This makes it possible, for example, to natively embed own Web Components of your design system which are created with Stencil. The integration embeds the Web Components in a way that they can be used naturally in XMLViews, like with standard UI5 controls, and can be bound with data binding. Learn how you can also make use of the Web Components base class in OpenUI5/SAPUI5 to also integrate your Web Components and get inspired by the solution to generate a custom UI5 library providing the Web Components control wrappers for the native ones.
Measures in SQL (SIGMOD 2024, Santiago, Chile)Julian Hyde
SQL has attained widespread adoption, but Business Intelligence tools still use their own higher level languages based upon a multidimensional paradigm. Composable calculations are what is missing from SQL, and we propose a new kind of column, called a measure, that attaches a calculation to a table. Like regular tables, tables with measures are composable and closed when used in queries.
SQL-with-measures has the power, conciseness and reusability of multidimensional languages but retains SQL semantics. Measure invocations can be expanded in place to simple, clear SQL.
To define the evaluation semantics for measures, we introduce context-sensitive expressions (a way to evaluate multidimensional expressions that is consistent with existing SQL semantics), a concept called evaluation context, and several operations for setting and modifying the evaluation context.
A talk at SIGMOD, June 9–15, 2024, Santiago, Chile
Authors: Julian Hyde (Google) and John Fremlin (Google)
https://doi.org/10.1145/3626246.3653374
1. GateIn Introduction
Michal Vančo & Miroslav Cupák
JBoss QA
22 Nov, 2011
Abstract:
This presentation is an introduction to portal and portlets basics,
features and UI of GateIn Portal. Workshop covers specification
details for portlet development.
2. GateIn Introduction | FIT VUT2
Agenda
● Motivation for portals & portlets
● GateIn Overview (demo)
● JSR-168 / 286 Portlet development
● Lifecycle, API
● Tag library
● IPC (inter-portlet communication), resources etc.
● Workshop
8. GateIn Introduction | FIT VUT8
Portal
● A portal is a web based application that provides
personalization, single sign on, content aggregation
from different sources in the form of portlets.
● Framework for integration of information, people and
processes in an organization.
● Set of services/applications.
● Portal server.
9. GateIn Introduction | FIT VUT9
Types of portals
● General (yahoo.com)
● Community (MySpace.com)
● Business (Amazon.com)
● Information (BBC.co.uk, idnes.cz)
● Enterprise (GateIn, Liferay)
● Horizontal (Seznam.cz) vs. Vertical (CouchSurfing.org)
● B2B, B2C, B2E, G2C
13. GateIn Introduction | FIT VUT13
Portlet
● Small web application designed to be deployed on
portal server.
● Reusable web component generating dynamic content
(markup fragment) based on requests. Portal
aggregates portlet markup fragments into a complete
portal page.
15. GateIn Introduction | FIT VUT15
● Open source portal server.
● GateIn Portal is a merge of two mature projects that
have been around for a while, JBoss Portal (Red Hat)
and eXo Portal (eXo).
● Based on standards, selected services.
● ...and it's awesome!
22. GateIn Introduction | FIT VUT22
JSR-168
● Portlet vs. Servlet
● common features:
● generate dynamic content
● components based on Java
● lifecycle managed by container
● request/response model
● portlet specific features:
● generate fragment of pages
● not bound to URL
● communication via portal
● more complex request processing and behavior
● multiple instances on page
23. GateIn Introduction | FIT VUT23
Portlet container & lifecycle
● Manages lifecycle of portlets
● Distributes requests among portlets
24. GateIn Introduction | FIT VUT24
Portlet modes & window states
● Modes indicate current portlet function.
● 3 common modes: VIEW, EDIT, HELP.
● Window states determine the amount of space on the
page available to the portlet.
● 3 common states: NORMAL, MAXIMIZED, MINIMIZED.
● Custom states & modes.
25. GateIn Introduction | FIT VUT25
PortletPreferences & PortletSession
● Session is temporary storage of data to share among
portlets.
● Preferences are used to persist attributes (user-
specific key-value pairs). Typically set in EDIT mode
during processAction phase.
27. GateIn Introduction | FIT VUT27
Tag library
● Used in JSP pages
● <% taglib uri=”http://java.sun.com/portlet_2_0” prefix=”portlet” %>
● Allow access to portal specific request/response objects
● <portlet:defineObjects />
● Is used in JSP pages to generate links (actionURL,
renderURL, resourceURL)
● request/response objects can be accessed in scriplet or
EL expressions
31. GateIn Introduction | FIT VUT31
Workshop details
● Generate dynamic web project in JBDS with Portlet facet
● Generate simple portlet & deploy
● Update portlet to render content from JSP
● Create form in JSP & implement processAction
● add another JSP which displays value from form + use
renderURL to return
● Create help mode & display information about signed user
● add link to switch back to view mode (using renderURL)
● Advanced: create edit mode & implement storing and
display of PortletPreferences
32. GateIn Introduction | FIT VUT32
Important links
● http://jcp.org/en/jsr/detail?id=286
● http://www.jboss.org/gatein/
(Download page, User & Reference Guides)
● http://www.jboss.com/products/platforms/portals/
Contact
mvanco@redhat.com
mcupak@redhat.com