This document discusses porting a legacy application to use the Model-View-ViewModel (MVVM) and Composite Application Guidance (CAL) patterns. It defines key MVVM concepts like models, views, presenters, and presentation models. It outlines advantages of CAL like modularity, reusability, and separation of concerns. It then provides a sample scenario of a legacy life insurance application and steps to refactor it to use these patterns, including creating modules, services, and using regions to host views.
The document discusses various design patterns including Factory Method, Abstract Factory, Builder, Singleton, Adapter, Bridge, and Decorator patterns. It provides definitions and explanations of the intent, structure, participants, and sample code for implementing each pattern. The Factory Method pattern allows subclasses to determine which object to create, Abstract Factory creates families of related objects without specifying their concrete classes, and Builder separates object construction from representation. Singleton ensures only one instance, Adapter converts interfaces, Bridge decouples abstraction and implementation, and Decorator adds responsibilities dynamically. Design patterns provide reusable solutions to common programming problems.
Java Server Faces (JSF) is a Java web application framework that uses the model-view-controller (MVC) architectural pattern. JSF has a component-based user interface that separates UI components from business logic. It provides features like data binding, validation, internationalization and AJAX. JSF applications typically consist of JavaBeans components, JSP pages that represent views, and configuration files that define workflows between pages.
When you complete this module, you should be able to do these tasks :
• Explore the content of a module
• Analyze the information in a module
• Create, move, edit and delete artifacts in a module
• Identify and implement hierarchical data structures in a
module
The document describes the process of designing, developing, testing, and maintaining a configuration model in Oracle Configurator. It includes steps for creating the configuration model structure and rules, importing BOM and inventory data, developing the UI, testing, publishing the model, and refreshing imported data. Key aspects covered are the model structure, logical rules, importing BOM models and data, UI templates, publishing models, and refreshing imported BOM data.
This document provides an overview of Jazz source control as implemented in IBM Rational Team Concert. It defines key concepts like repositories, workspaces, streams, components, and change sets. It describes how developers can create and manage local workspaces and change sets, share changes with their team through operations like deliver and accept, find and resolve conflicts, and preserve configurations using baselines and snapshots. The document also provides guidance on troubleshooting and discarding unwanted changes.
In this module, you work at the project level. After you complete this module, you should be able to do these tasks :
• Upload requirements information as a recourse
• Create an artifact at the project level
• Create an artifact from another artifact
• Edit artifact attributes at the project level
• Export requirements from the project to a comma-separated values ( CSV) file
After you complete this module, you should be able to do these tasks :
- Generate requirements report documents
- Explain the reporting capability that is available through IBM® Rational® Reporting for Development Intelligence
The Composite Application Guidance for WPF and Silverlight is designed to help you more easily build enterprise-level Windows Presentation Foundation (WPF) client applications.
The document discusses various design patterns including Factory Method, Abstract Factory, Builder, Singleton, Adapter, Bridge, and Decorator patterns. It provides definitions and explanations of the intent, structure, participants, and sample code for implementing each pattern. The Factory Method pattern allows subclasses to determine which object to create, Abstract Factory creates families of related objects without specifying their concrete classes, and Builder separates object construction from representation. Singleton ensures only one instance, Adapter converts interfaces, Bridge decouples abstraction and implementation, and Decorator adds responsibilities dynamically. Design patterns provide reusable solutions to common programming problems.
Java Server Faces (JSF) is a Java web application framework that uses the model-view-controller (MVC) architectural pattern. JSF has a component-based user interface that separates UI components from business logic. It provides features like data binding, validation, internationalization and AJAX. JSF applications typically consist of JavaBeans components, JSP pages that represent views, and configuration files that define workflows between pages.
When you complete this module, you should be able to do these tasks :
• Explore the content of a module
• Analyze the information in a module
• Create, move, edit and delete artifacts in a module
• Identify and implement hierarchical data structures in a
module
The document describes the process of designing, developing, testing, and maintaining a configuration model in Oracle Configurator. It includes steps for creating the configuration model structure and rules, importing BOM and inventory data, developing the UI, testing, publishing the model, and refreshing imported data. Key aspects covered are the model structure, logical rules, importing BOM models and data, UI templates, publishing models, and refreshing imported BOM data.
This document provides an overview of Jazz source control as implemented in IBM Rational Team Concert. It defines key concepts like repositories, workspaces, streams, components, and change sets. It describes how developers can create and manage local workspaces and change sets, share changes with their team through operations like deliver and accept, find and resolve conflicts, and preserve configurations using baselines and snapshots. The document also provides guidance on troubleshooting and discarding unwanted changes.
In this module, you work at the project level. After you complete this module, you should be able to do these tasks :
• Upload requirements information as a recourse
• Create an artifact at the project level
• Create an artifact from another artifact
• Edit artifact attributes at the project level
• Export requirements from the project to a comma-separated values ( CSV) file
After you complete this module, you should be able to do these tasks :
- Generate requirements report documents
- Explain the reporting capability that is available through IBM® Rational® Reporting for Development Intelligence
The Composite Application Guidance for WPF and Silverlight is designed to help you more easily build enterprise-level Windows Presentation Foundation (WPF) client applications.
Bricano is an e-commerce marketplace for construction materials where customers can choose products based on their requirements. The document outlines different modules for the admin, reviewers, moderators, vendors, and customers on the site. It describes the functionality and menus for each module, which allows for adding, viewing, and reviewing products on the site.
The document discusses the Model-View-Controller (MVC) design pattern. It explains that MVC separates an application into three main components: the Model, the View, and the Controller. The Model manages the data logic, the View displays the presentation logic, and the Controller handles user input and interaction between the Model and View. Some key benefits of MVC include flexibility to change views without affecting other components, and separating concerns for improved maintenance and testing.
This document provides an overview of IBM MobileFirst Platform's operational analytics features. It describes how the analytics platform collects and analyzes data from mobile applications, servers, and devices to provide visibility into performance and usage. The analytics console contains various views and capabilities for searching logs, viewing charts and reports, and diagnosing issues. It summarizes the different data sources, events captured, and the client and server APIs used to log additional analytics data. The document then outlines the steps to access the analytics console and walk through its key pages and functionality.
In this webinar there will be a brief discussion on what is personalization, customization and extension. Lastly, we will be talking about the role of ADF, which is going to supersede OA Framework in fusion applications.
(ATS6-DEV07) Building widgets for ELN home pageBIOVIA
From a developer’s perspective, the Accelrys ELN Home Page is a container of widgets. It manages the layout of widgets, and handles the persistence of their settings. Several widgets are provided with the application: one for creating new experiments, another for tracking work in progress, and an inbox widget for messages sent through the notebook. This out-of-the-box set can be supplemented by building custom widgets.
This session will show several custom widgets examples to demonstrate the basic concepts of widget development and the API they implement. We will also discuss best practices, and how to make your widget a good citizen of the Home Page.
The document discusses advanced topics in Xamarin.Forms including data template selectors, themes/styles, behaviors, triggers, renderers, effects, dependency services, platform-specifics, and the visual state manager. Data template selectors allow choosing templates at runtime based on data. Styles customize control appearance by grouping properties. Behaviors add functionality without subclassing. Triggers change appearance based on events. Renderers and effects customize native controls. Dependency services access native functionality. Platform-specifics consume platform-only features. The visual state manager structurally changes the UI from code.
With the great flexibility that xCP 2.0 gives developers when configuring
applications comes the complexity of understanding the best approaches to take
when meeting business requirements.
In some cases there may only be a single design pattern that will meet a business
requirement, and in other cases there may be several valid patterns, but only one
that is expected to meet performance requirements.
The aim of this white paper is to provides guidelines for designing and
configuring an xCP 2.0 application to meet business requirements based on the
experience of EMC subject matter experts.
This version of the document focuses on the design and configuration of the
application model and business processes.
This document provides an overview of the Model-View-Controller (MVC) framework in ASP.Net. It discusses the history and components of MVC, including the model, view, and controller. The model manages the application's data logic. The view displays the user interface. The controller handles input and communication between the model and view. It provides steps for creating an ASP.Net MVC application and describes the typical file structure, including models, views, and controllers folders. It also explains how to add classes, write action methods, and create views to display and return data.
This document provides instructions for an exercise on managing work items in IBM Rational Team Concert. The purpose is to become familiar with creating, querying, triaging, and working on work items. Specific tasks covered include creating a defect work item, creating simple and more complex queries to find work items by properties and conditions, and joining a project team to accept work items.
After you complete this module, you should be able to manage change by doing these tasks :
- Identify changed artifacts
- Explore the history of an artifact
- Identify suspect traceability
This document describes a lab exercise to demonstrate application management functions in IBM MobileFirst using the MobileFirst Operations Console. The lab will:
1. Deploy an initial version of an IBMBank mobile application to a MobileFirst Server.
2. Publish an updated version of the application to fix a bug, and test the "Direct Update" feature which pushes changes to client devices.
3. Configure application status notifications via the MobileFirst Operations Console and see them displayed on an Android emulator.
The document introduces the Enhancement Framework, a new paradigm in SAP NetWeaver 2004s for enhancing ABAP systems. It brings together different enhancement techniques under one framework and improves how SAP software can be adapted. The Enhancement Framework supports source code, function group, class and BADI enhancements. It allows enhancements to be managed and transported centrally.
This document provides instructions for a lab exercise on getting started with IBM MobileFirst Platform. It introduces the key concepts of MobileFirst Platform Studio and walks through steps to import a sample banking application project, examine the project structure, add an Android environment, and preview the application in the Mobile Browser Simulator and an Android device. It also demonstrates how to invoke backend services using adapters and view analytics data from the MobileFirst Operations Console. The document contains detailed steps, screenshots and explanations to help users learn fundamental MobileFirst Platform development tasks.
Where Does IBM Web Experience Factory Fit in your Architecture? TECH-D22 from...Davalen LLC
Web Experience Factory (WEF) has matured as a framework and web and mobile solution development tool over the last several years. While the WEF design interface and services enable rapid custom development, too often implementation emphasis has focused more on speed versus how it fits into proper architecture.(The tendency is just start coding)! By its nature WEF allows for many levels of integration, but it still has to be structured in a way that fits proper design. This session is geared towards IT architects and developers and provides guidance to leverage WEF as a part of their overall architectural plan. We will discuss how WEF fits in various combinations of architecture. The goal will be to refer to best practices patterns, identify where WEF “fits” in your plan and to give you a head start on a successful use of WEF in your multichannel solutions.
Topics covered will include
WEF in Architectural patterns
A sample Navigation Pattern in the View
Some Patterns for WEF page automation and profiling
Starting and governing a WEF project including QA
Integrating your unique developer skills with WEF
This document provides an overview and instructions for using reports and dashboards in Rational Team Concert. It describes how to view existing reports, create new reports from templates, and customize personal dashboards. Dashboards in the web client include project, team, and personal views to track status. The document teaches how to add widgets to personal dashboards and share them with other users.
This document provides instructions for an exercise on managing builds in IBM Rational Team Concert. The exercise covers exploring existing builds, requesting a team build, comparing builds, and optionally requesting a personal build. Key steps include examining build details, requesting a team build for the JavaUI project, comparing the most recent build to an older one, and requesting a personal build using a personal workspace to test changes.
This document provides an overview of the approach and key considerations for upgrading an Oracle E-Business Suite instance from Release 11i to Release 12. It discusses conducting functional and technical discovery analyses, building and testing the new version, preparing end users, and executing the cutover. It also highlights some new features in R12 like assigning item images in iProcurement, enhanced security for concurrent program access, using custom payment formats, and the ability to generate accounting entries from revenue distribution accounts using sub-ledger accounting functionality.
Ctools is a suite of tools and APIs that make development easier in Drupal. It includes tools like Exportables for defining reusable configuration presets, the Ajax Responder for handling AJAX requests simply, the Form Wizard for building multi-step forms, the Modal Dialog for creating popup forms, and others. The tools aim to simplify common tasks and provide standardized approaches.
This document provides an overview of custom controllers and controller extensions in Visualforce, including:
- A custom controller is an Apex class that implements all logic for a page without using a standard controller, while a controller extension extends the functionality of a standard or custom controller.
- Controller extensions are useful for leveraging standard controllers while overriding actions, adding new actions, or building pages that respect user permissions.
- The document discusses building custom controllers and controller extensions, calling them from Visualforce pages, and considerations for working with sharing rules and large data sets.
Should I Be Writing My Own Web Experience Factory Builder? TECH-D13 from IBM ...Davalen LLC
TECH-D13: Should I write my own Builder? Increase productivity by identifying and capturing repeatable design patterns within Web Experience Factory
David Wade, Davalen’s Web Experience Factory Architect
Adam Kewley, Web Experience Factory Lead, Davalen
Description: Writing efficient code in a modular fashion is a fundamental concept in developing quality software that must grow and change as business dictates. Capturing key components for reusability enables your developers to capitalize on shared knowledge through proper use of repeatable design patterns. This session is geared towards IT managers, architects and developers who wish to not only learn how to properly capture design patterns in IBM Web Experience Factory (WEF), but when to spot the need for such mechanisms. Utilizing existing techniques and features within WEF to generate your own library of repeatable functionality. Only available at the IBM Exceptional Web Experience conference, learn from a seasoned lead architect with applicable world-class practical knowledge.
Some topics covered will include:
Breaking down code reuse: builders, models, ljo's (what is this...)
Identifying reuse areas at a project level
How to decide between a builder and a model
Other areas of code reuse (data retrievers, LJO's services)
Pitfalls to avoid
The document discusses the Rapid Reaction Technology Office (RRTO) and its goals of developing capabilities to support irregular warfare and counterterrorism efforts. It aims to leverage various science and technology resources, anticipate threats, and accelerate the development and fielding of affordable solutions. Key areas of focus include intelligence enhancement, surveillance, non-kinetic capabilities, and interagency coordination on issues like biometrics and strategic communications.
Challenge on Academic Advising: Selected SubmissionsDiana Woolis
The Bill & Melinda Gates Foundation selected 9 out of 76 submissions to attend their Post-Secondary Success convening in September 2013. The selected submissions showcased innovative academic advising programs that addressed non-cognitive student support, utilized technology, and involved collaborative partnerships. Examples included using ePortfolios to develop students' skills, integrating culture into advising, and employing data to target at-risk groups. Peer coaching and mentoring models engaged students as advisors. The goal was to highlight advising approaches that improve outcomes for 21st century learners.
Bricano is an e-commerce marketplace for construction materials where customers can choose products based on their requirements. The document outlines different modules for the admin, reviewers, moderators, vendors, and customers on the site. It describes the functionality and menus for each module, which allows for adding, viewing, and reviewing products on the site.
The document discusses the Model-View-Controller (MVC) design pattern. It explains that MVC separates an application into three main components: the Model, the View, and the Controller. The Model manages the data logic, the View displays the presentation logic, and the Controller handles user input and interaction between the Model and View. Some key benefits of MVC include flexibility to change views without affecting other components, and separating concerns for improved maintenance and testing.
This document provides an overview of IBM MobileFirst Platform's operational analytics features. It describes how the analytics platform collects and analyzes data from mobile applications, servers, and devices to provide visibility into performance and usage. The analytics console contains various views and capabilities for searching logs, viewing charts and reports, and diagnosing issues. It summarizes the different data sources, events captured, and the client and server APIs used to log additional analytics data. The document then outlines the steps to access the analytics console and walk through its key pages and functionality.
In this webinar there will be a brief discussion on what is personalization, customization and extension. Lastly, we will be talking about the role of ADF, which is going to supersede OA Framework in fusion applications.
(ATS6-DEV07) Building widgets for ELN home pageBIOVIA
From a developer’s perspective, the Accelrys ELN Home Page is a container of widgets. It manages the layout of widgets, and handles the persistence of their settings. Several widgets are provided with the application: one for creating new experiments, another for tracking work in progress, and an inbox widget for messages sent through the notebook. This out-of-the-box set can be supplemented by building custom widgets.
This session will show several custom widgets examples to demonstrate the basic concepts of widget development and the API they implement. We will also discuss best practices, and how to make your widget a good citizen of the Home Page.
The document discusses advanced topics in Xamarin.Forms including data template selectors, themes/styles, behaviors, triggers, renderers, effects, dependency services, platform-specifics, and the visual state manager. Data template selectors allow choosing templates at runtime based on data. Styles customize control appearance by grouping properties. Behaviors add functionality without subclassing. Triggers change appearance based on events. Renderers and effects customize native controls. Dependency services access native functionality. Platform-specifics consume platform-only features. The visual state manager structurally changes the UI from code.
With the great flexibility that xCP 2.0 gives developers when configuring
applications comes the complexity of understanding the best approaches to take
when meeting business requirements.
In some cases there may only be a single design pattern that will meet a business
requirement, and in other cases there may be several valid patterns, but only one
that is expected to meet performance requirements.
The aim of this white paper is to provides guidelines for designing and
configuring an xCP 2.0 application to meet business requirements based on the
experience of EMC subject matter experts.
This version of the document focuses on the design and configuration of the
application model and business processes.
This document provides an overview of the Model-View-Controller (MVC) framework in ASP.Net. It discusses the history and components of MVC, including the model, view, and controller. The model manages the application's data logic. The view displays the user interface. The controller handles input and communication between the model and view. It provides steps for creating an ASP.Net MVC application and describes the typical file structure, including models, views, and controllers folders. It also explains how to add classes, write action methods, and create views to display and return data.
This document provides instructions for an exercise on managing work items in IBM Rational Team Concert. The purpose is to become familiar with creating, querying, triaging, and working on work items. Specific tasks covered include creating a defect work item, creating simple and more complex queries to find work items by properties and conditions, and joining a project team to accept work items.
After you complete this module, you should be able to manage change by doing these tasks :
- Identify changed artifacts
- Explore the history of an artifact
- Identify suspect traceability
This document describes a lab exercise to demonstrate application management functions in IBM MobileFirst using the MobileFirst Operations Console. The lab will:
1. Deploy an initial version of an IBMBank mobile application to a MobileFirst Server.
2. Publish an updated version of the application to fix a bug, and test the "Direct Update" feature which pushes changes to client devices.
3. Configure application status notifications via the MobileFirst Operations Console and see them displayed on an Android emulator.
The document introduces the Enhancement Framework, a new paradigm in SAP NetWeaver 2004s for enhancing ABAP systems. It brings together different enhancement techniques under one framework and improves how SAP software can be adapted. The Enhancement Framework supports source code, function group, class and BADI enhancements. It allows enhancements to be managed and transported centrally.
This document provides instructions for a lab exercise on getting started with IBM MobileFirst Platform. It introduces the key concepts of MobileFirst Platform Studio and walks through steps to import a sample banking application project, examine the project structure, add an Android environment, and preview the application in the Mobile Browser Simulator and an Android device. It also demonstrates how to invoke backend services using adapters and view analytics data from the MobileFirst Operations Console. The document contains detailed steps, screenshots and explanations to help users learn fundamental MobileFirst Platform development tasks.
Where Does IBM Web Experience Factory Fit in your Architecture? TECH-D22 from...Davalen LLC
Web Experience Factory (WEF) has matured as a framework and web and mobile solution development tool over the last several years. While the WEF design interface and services enable rapid custom development, too often implementation emphasis has focused more on speed versus how it fits into proper architecture.(The tendency is just start coding)! By its nature WEF allows for many levels of integration, but it still has to be structured in a way that fits proper design. This session is geared towards IT architects and developers and provides guidance to leverage WEF as a part of their overall architectural plan. We will discuss how WEF fits in various combinations of architecture. The goal will be to refer to best practices patterns, identify where WEF “fits” in your plan and to give you a head start on a successful use of WEF in your multichannel solutions.
Topics covered will include
WEF in Architectural patterns
A sample Navigation Pattern in the View
Some Patterns for WEF page automation and profiling
Starting and governing a WEF project including QA
Integrating your unique developer skills with WEF
This document provides an overview and instructions for using reports and dashboards in Rational Team Concert. It describes how to view existing reports, create new reports from templates, and customize personal dashboards. Dashboards in the web client include project, team, and personal views to track status. The document teaches how to add widgets to personal dashboards and share them with other users.
This document provides instructions for an exercise on managing builds in IBM Rational Team Concert. The exercise covers exploring existing builds, requesting a team build, comparing builds, and optionally requesting a personal build. Key steps include examining build details, requesting a team build for the JavaUI project, comparing the most recent build to an older one, and requesting a personal build using a personal workspace to test changes.
This document provides an overview of the approach and key considerations for upgrading an Oracle E-Business Suite instance from Release 11i to Release 12. It discusses conducting functional and technical discovery analyses, building and testing the new version, preparing end users, and executing the cutover. It also highlights some new features in R12 like assigning item images in iProcurement, enhanced security for concurrent program access, using custom payment formats, and the ability to generate accounting entries from revenue distribution accounts using sub-ledger accounting functionality.
Ctools is a suite of tools and APIs that make development easier in Drupal. It includes tools like Exportables for defining reusable configuration presets, the Ajax Responder for handling AJAX requests simply, the Form Wizard for building multi-step forms, the Modal Dialog for creating popup forms, and others. The tools aim to simplify common tasks and provide standardized approaches.
This document provides an overview of custom controllers and controller extensions in Visualforce, including:
- A custom controller is an Apex class that implements all logic for a page without using a standard controller, while a controller extension extends the functionality of a standard or custom controller.
- Controller extensions are useful for leveraging standard controllers while overriding actions, adding new actions, or building pages that respect user permissions.
- The document discusses building custom controllers and controller extensions, calling them from Visualforce pages, and considerations for working with sharing rules and large data sets.
Should I Be Writing My Own Web Experience Factory Builder? TECH-D13 from IBM ...Davalen LLC
TECH-D13: Should I write my own Builder? Increase productivity by identifying and capturing repeatable design patterns within Web Experience Factory
David Wade, Davalen’s Web Experience Factory Architect
Adam Kewley, Web Experience Factory Lead, Davalen
Description: Writing efficient code in a modular fashion is a fundamental concept in developing quality software that must grow and change as business dictates. Capturing key components for reusability enables your developers to capitalize on shared knowledge through proper use of repeatable design patterns. This session is geared towards IT managers, architects and developers who wish to not only learn how to properly capture design patterns in IBM Web Experience Factory (WEF), but when to spot the need for such mechanisms. Utilizing existing techniques and features within WEF to generate your own library of repeatable functionality. Only available at the IBM Exceptional Web Experience conference, learn from a seasoned lead architect with applicable world-class practical knowledge.
Some topics covered will include:
Breaking down code reuse: builders, models, ljo's (what is this...)
Identifying reuse areas at a project level
How to decide between a builder and a model
Other areas of code reuse (data retrievers, LJO's services)
Pitfalls to avoid
The document discusses the Rapid Reaction Technology Office (RRTO) and its goals of developing capabilities to support irregular warfare and counterterrorism efforts. It aims to leverage various science and technology resources, anticipate threats, and accelerate the development and fielding of affordable solutions. Key areas of focus include intelligence enhancement, surveillance, non-kinetic capabilities, and interagency coordination on issues like biometrics and strategic communications.
Challenge on Academic Advising: Selected SubmissionsDiana Woolis
The Bill & Melinda Gates Foundation selected 9 out of 76 submissions to attend their Post-Secondary Success convening in September 2013. The selected submissions showcased innovative academic advising programs that addressed non-cognitive student support, utilized technology, and involved collaborative partnerships. Examples included using ePortfolios to develop students' skills, integrating culture into advising, and employing data to target at-risk groups. Peer coaching and mentoring models engaged students as advisors. The goal was to highlight advising approaches that improve outcomes for 21st century learners.
Money can't buy you love, Goldsmiths Social Entrepreneurship MBAStephen Rockman
The document provides brief biographical information about Stephen Rockman, including that he has 20 years of experience in technology, 6 years of seed investing and advising startups, works at Merism Capital, and is a serial father. It then lists factors important for startup success including management, momentum, market, money, being passionate, realistic, and focused, and notes the relationship between investors and founders is symbiotic and perhaps a little erotic. It concludes with copyright information for Merism Capital LLP.
IARPA automated low level analysis and description of diverse intelligence vi...Kaye Beach
The document is a Broad Agency Announcement from the Intelligence Advanced Research Projects Activity (IARPA) soliciting proposals for the Automated Low-level Analysis and Description of Diverse Intelligence Video (ALADDIN) program. The goal of the ALADDIN program is to develop technology that can automatically analyze massive numbers of open source video clips to identify and describe clips containing specific events of interest defined by analysts. The technology would create a symbolic representation of video content that could be quickly searched to find event occurrences and provide detailed yet understandable descriptions. IARPA is seeking innovative solutions through this Broad Agency Announcement and anticipates making multiple awards for contracts starting in early 2011 through early 2016.
Funder requirements for Data Management PlansSherry Lake
This document discusses funder requirements for data management and sharing. It notes that major funders like the National Science Foundation (NSF) and National Institutes of Health (NIH) require applicants to submit a data management plan. These plans describe how research data will be organized, preserved, and shared. The document provides details on what funders expect to see in a data management plan, including a description of the data, metadata standards, data access and sharing policies, and plans for long-term data preservation. It also lists other funders that require applicants to have a data management or sharing plan.
The document discusses several sustainability and climate initiatives undertaken by local governments including Local Agenda 21, climate change action planning, renewable energy projects, advocacy related to climate negotiations, biodiversity protection efforts, sustainable procurement, and capacity building for sustainability management.
Pattern oriented architecture for web based architectureshuchi tripathi
This document discusses web application architecture and design patterns. It describes a three-layer architecture with presentation, application, and data layers. For the presentation layer, forms are commonly used to structure user interfaces. The application layer focuses on business processes and components. The data access layer exposes database data. Popular design patterns like MVC, PAC, and others are explained as ways to achieve separation of concerns and improve maintainability. MVC divides the presentation layer into separate controller and view components. PAC defines a hierarchical structure of cooperating agents with presentation, abstraction, and control components.
The document discusses the Model-View-Controller (MVC) architectural pattern. MVC separates an application into three main components: the model, the view, and the controller. The model manages the behavior and data of the application, the view manages the display of the model, and the controller handles input and interaction with the model and view. The document provides examples of how MVC is implemented in different frameworks like ASP.NET, Windows Forms, and Java Server Pages.
The document discusses several design patterns for Java EE applications:
- Model-View-Controller (MVC) separates an application into three main components - the model, the view, and the controller.
- Intercepting Filter allows preprocessing and postprocessing of requests and responses without changing core processing code. Filters can add or remove services like security and logging.
- Front Controller provides a centralized entry point to handle requests and coordinate other components like views.
- View Helper moves business logic from views to separate helper classes to improve modularity.
The document discusses various software architecture patterns and principles, comparing monolithic and microservices architectures. It covers topics like layers, domain-driven design, code-first versus database-first approaches, and considerations for data management in multi-tenant systems. The key aspects of architectures like microservices and domain-driven design are explained at a high level.
The document discusses the Model-View-Controller (MVC) design pattern. MVC separates an application's data (model), user interface (view), and control logic (controller) into three independent components. This allows for flexible development and testing. The model manages application data and logic, the view displays the data, and the controller handles user input and invokes changes to the model and view. When a user interacts with the view, the controller updates the model and the view refreshes from the model. MVC promotes loose coupling between these components and is widely used in web applications.
The document discusses the Presentation-Abstraction-Control (PAC) pattern for developing web applications. PAC defines a hierarchical structure of cooperating agents, where each agent is responsible for a specific aspect of the application. Each agent consists of three components: presentation, abstraction, and control. The presentation component handles human-computer interaction, the abstraction component manages the data model, and the control component mediates communication between agents. The PAC pattern supports modularity, change, extension, and multitasking through separation of these components within agents.
The document discusses the Presentation-Abstraction-Control (PAC) pattern for developing web applications. PAC defines a hierarchical structure of cooperating agents, where each agent is responsible for a specific aspect of the application. Each agent consists of three components: presentation, abstraction, and control. The presentation component handles human-computer interaction, the abstraction component manages the data model, and the control component mediates communication between agents. The PAC pattern supports modularity, change, extension, and multitasking through separation of these components within agents.
The document discusses the Model-View-ViewModel (MVVM) architectural pattern. MVVM consists of separating an application into three components: the Model (data access), the View (user interface), and the ViewModel (mediator between Model and View). The ViewModel processes data from the Model to present it to the View and passes user input from the View to the Model. This separation allows changes to one component without affecting the others, improving maintainability and testability. The document also discusses using MVVM with C# for the Model, TypeScript for ViewModels, and HTML5 for Views, connected with KnockoutJS for data binding.
The document discusses interaction-oriented software architectures, specifically Model-View-Controller (MVC) and Presentation-Abstraction-Control (PAC) architectures. MVC separates a software application into three parts - the model manages the core data and logic, the view displays the data to the user, and the controller handles input. PAC uses multiple interacting agents that each contain a presentation component, abstraction component, and control component to coordinate communication. Both styles aim to separate user interaction from data processing and support interactive applications.
AngularJS is a structural framework for dynamic web apps. It lets you use HTML as your template language and lets you extend HTML's syntax to express your application's components clearly and succinctly. AngularJS's data binding and dependency injection eliminate much of the code you would otherwise have to write. And it all happens within the browser, making it an ideal partner with any server technology.
AngularJS is a JavaScript framework for building dynamic web applications. It augments HTML with custom attributes and directives to bind data and behaviors to the DOM. Key features include two-way data binding, reusable components, dependency injection, routing, and templating. AngularJS uses an MVC or MVVM pattern, with scopes providing the view model. The framework enhances HTML, encourages test-driven development, and makes single page apps possible.
Introduction to Angular js , Angular js PDF , What is angular js ?? angular js pdf explanied. introduction to angular js. angular js online slide presentations. angular js explained pdf introductions
Mvc pattern and implementation in java fairTech_MX
The document discusses the MVC pattern for developing user interfaces, which separates an application into three components - the model manages the core data and logic, the view handles visual presentation of the data to the user, and the controller receives user input and translates it into actions on the model. The MVC pattern promotes separation of concerns, makes the code more modular and reusable, and allows independent development and updating of each component without impacting the others. Common implementations of MVC involve the model notifying subscribed views of any data changes, the controller handling user input to update the model and selecting views, and views updating their presentation when the model changes.
The document discusses the Model-View-Controller (MVC) design pattern. MVC separates an application's logic into three main components: the model, the view, and the controller. The model manages the application's data and logic, the view displays the data to the user, and the controller interprets user input and updates the model. MVC improves separation of concerns and makes applications more modular, extensible, and testable. It is commonly used for web applications, where the server handles the model and controller logic while the client handles the view.
This document provides an overview of the Model-View-Controller (MVC) architecture pattern that is commonly used for iOS app development. It explains that MVC separates an app into three main components: the model layer contains the business logic and data; the view layer contains the user interface elements; and the controller layer mediates interactions between the model and view. Adopting MVC makes code more organized, reusable, readable and maintainable, especially for large teams. It also allows for more flexibility in the development process and easier testing. While initially challenging, following the MVC pattern provides significant benefits over the long run.
The document discusses the Model-View-Controller (MVC) pattern and ASP.NET MVC framework. It describes the key components of MVC - the Model, View and Controller. The Controller handles communication from the user, application flow and logic. The Model represents application data and business rules. The View displays the user interface. ASP.NET MVC is an MVC web application framework for ASP.NET that was open sourced by Microsoft. New versions of ASP.NET MVC added features like Razor view engine, model validation, and Web API for building HTTP services.
This document provides an overview of the MVC architecture pattern. It defines the core components of MVC - the model, view, and controller. The model manages the application's data and logic. The view displays the UI. The controller handles user input and interaction and selects views. MVC promotes separation of concerns, testability, and parallel development. It allows full control over an application's behavior and supports test-driven development well.
The document discusses the Model-View-Controller (MVC) design pattern. MVC separates an application's data (model), user interface (view), and control logic (controller) to reduce failures. It provides modularity, allowing changes to one component without affecting others. MVC supports multiple views of the same data and powerful user interfaces through its separation of concerns.
Similar to Porting the Legacy Application to Composite Application Guidance (20)
Don Burnett has over 30 years of experience in multimedia development, training, and support roles. He has extensive experience with Microsoft technologies like Windows Presentation Foundation, Silverlight, ASP.NET, and Expression products. Some of his past roles include training instructors at Microsoft, developing websites and applications for various companies, and creating multimedia content and assets. He also has experience in mobile app development for Windows Phone and Kinect-enabled kiosk creation.
This document discusses how to prove the return on investment (ROI) of user experience (UX) design to clients. It recommends identifying decision-makers and influencers as targets, understanding what metrics and language they use, and framing UX value in terms of those metrics. The document also suggests using multiple research methods, matching them to desired outcomes, and mapping UX assets like wireframes back to business goals to demonstrate how UX will help achieve those goals. The overall goal is to change stakeholders' beliefs about UX value and its ability to impact metrics like efficiency, revenue, and brand recognition.
This document compares coding and tools for developing apps on the iPhone versus Windows Phone 7. It provides a step-by-step example of creating a simple "hello world" master-detail app on the iPhone using Xcode and Objective-C. It then ports the same example to Windows Phone 7 to show differences between the two platforms. The document aims to provide an unbiased comparison for developers to evaluate the strengths and weaknesses of each mobile development environment.
SketchFlow allows users to quickly prototype and iterate on user interface designs without extensive time or resource investments. It provides an informal way to explore ideas and evolve rough concepts into living prototypes. This rapid and cost-effective approach focuses on being creative and building the best solution.
Effective prototyping with SketchFlow allows experimenting with application flow, screen layouts, and state transitions. The interactive player engages clients by displaying working prototypes and collecting feedback directly in Expression Blend.
Agile practices like iterative development and user-centered design help teams collaborate effectively and respond quickly to change.
The document discusses controls in WPF, including the object model, base classes like Visual, UIElement, FrameworkElement, and Control. It covers creating new controls by deriving from classes like UserControl or Control, and using templates to define a control's appearance separately from its behavior. Styles and templates allow grouping property values and reusing control definitions while changing just the visual representation.
The document discusses various aspects of the WPF application model including properties, events, commands, threading, animation, and triggers. It covers core concepts like the application class, element trees, routed events, dependency properties, commands framework, threading with dispatchers, and the different types of triggers in WPF. The document provides an overview of these key WPF concepts and how they work together to build Windows Presentation Foundation applications.
This document provides an overview of panels and layout in WPF. It discusses the built-in panels like Canvas, StackPanel, WrapPanel, DockPanel and Grid. It also covers layout properties, transforms, creating custom panels, and the two phase layout process of measure and arrange.
Windows Presentation Foundation (WPF) provides a unified approach to user interface (UI), documents, and media for desktop applications. It uses XAML and declarative programming to simplify collaboration between designers and developers. WPF provides vector-based composition, 3D graphics, data binding, animation and other features. Many companies use WPF for applications involving media, visualization, and user interfaces.
This document provides an overview of key differences between Adobe Flash and Microsoft Expression Studio/Blend when designing user interfaces. It discusses concepts like symbols, movie clips, buttons, and graphics in Flash compared to controls, templates, styles, and resources in Blend. It also covers topics like data binding, events, visual states, and the integration of Blend with Visual Studio for coding functionality.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
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!
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
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.
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Best 20 SEO Techniques To Improve Website Visibility In SERPPixlogix Infotech
Boost your website's visibility with proven SEO techniques! Our latest blog dives into essential strategies to enhance your online presence, increase traffic, and rank higher on search engines. From keyword optimization to quality content creation, learn how to make your site stand out in the crowded digital landscape. Discover actionable tips and expert insights to elevate your SEO game.
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.
“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.
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
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.
AI 101: An Introduction to the Basics and Impact of Artificial IntelligenceIndexBug
Imagine a world where machines not only perform tasks but also learn, adapt, and make decisions. This is the promise of Artificial Intelligence (AI), a technology that's not just enhancing our lives but revolutionizing entire industries.
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.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Porting the Legacy Application to Composite Application Guidance
1. Porting the Legacy
Application to
MVVM/Composite
Application Guidance
By Don Burnett
2. Definitions
• Model: The underlying business entities that represent the data in your
system.
• View: The user interface representation of the underlying Model).
• Presenter: When the Model can provide the data that the View requires
without any complex manipulation or transformation, then the View binds
directly to the Model and the Presenter handles the state of the View in
the cases where complex user interface logic is required, such as changing
colours of controls and showing/hiding controls
• PresentationModel: When the View cannot bind directly to the Model, a
PresentationModel class is used to provide the Model in a format more
easily consumed by the View acting as a façade. The PresentationModel
class also manages UI-specific state and behaviour.
• Controller: Controller classes to manage the interaction between multiple
views.
3. Advantages
• CAL (Composite Application Library) allows modules to be individually developed, tested, and
deployed by different individuals or sub-teams; they also allow them to be modified or extended
with new functionality more easily, thereby allowing the application to be more easily extended
and maintained. Note that even single-person projects experience benefits in creating more
testable and maintainable applications using the composite approach.
• Provide a common shell composed of UI components contributed from various modules that
interact in a loosely coupled way. This reduces the contention that arises from multiple
developers adding new functionality to the UI, and it promotes a common appearance.
• Promote re-use and a clean separation of concerns between the application's horizontal
capabilities, such as logging and authentication, and the vertical capabilities, such as business
functionality that is specific to your application.
• Help maintain a separation of roles by allowing different individuals or sub-teams to focus on a
specific task or piece of functionality according to their focus or expertise. Provide a cleaner
separation between the user interface and the business logic of the application
• Doing all of this this means the UI designer can focus on creating a richer user experience.
• Composite applications are highly suited to a range of client application scenarios. For example,
a composite application is ideal for creating a rich end-user experience over a number of
disparate back-end systems.
4. Ficticious Legacy Application Scenario
• We are working at a life insurance office and
the application lets us look at our client’s life
insurance policies.
• It was done in Winforms and has since been
moved to WPF, but still uses code behinds.
• It is inefficient to scale as they have a growing
number of customers and branch offices.
5. First Step
• Create the Bootstrapper
• Added references to the following Prism assemblies in
my main (shell) project:
– Microsoft.Practices.Composite.dll
– Microsoft.Practices.Composite.Wpf.dll
– Microsoft.Practices.UnityExceptions.dll
– Microsoft.Practices.Unit.dll
– Microsoft.Practices.ObjectBuilder.dll
• Added a new class called MyApplicationBootstrapper,
which inherits from UnityBootstrapper as shown in the
following code example.
6. My Bootstrapper
public class MyApplicationBootstrapper :
UnityBootstrapper { protected override
DependencyObject CreateShell()
{ MainWindow window = new MainWindow();
window.Show(); return window;
}
protected override IModuleEnumerator
GetModuleEnumerator()
{
return new StaticModuleEnumerator(); }
}
7. First Step Continued..
• Removed the StartupUri property from App.xaml. Note
if you design in Expression Blend this will automatically
get added to App.xaml, you have to keep removing it if
you notice it showing up again.
• Created an instance of in the Application.Startup
event handler as shown in the following code example.
private void Application_Startup(object sender, StartupEventArgs
e)
{ MyApplicationBootstrapper bootstrapper = new
MyApplicationBootstrapper();
bootstrapper.Run();
}
8. Next Steps
• The application runs as it did before but now
it uses a Bootstrapper. No benefits yet, but it
works.
• Next step, start writing some tests and a some
modules to contain the existing UI controls as
views in a more Prism-like approach.
9. Application Structure Overview
• Our pretend legacy application consists primarily of a WPF user interface,
a WCF service that provides access to a SQL Server database and a few
support libraries.
• One of the support libraries provides some classes that deal with the
interaction between the user interface and the WCF service and is my
prime candidate for making some improvements using the Prism
guidance.
• The plan: create Prism Modules for the project and to create the relevant
Views, ViewModels, Services, and Controllers that are required to
implement the functionality. Rather than having to fully re-write the
underlying code that handles UI/WCF Service interaction.
• Write a Prism “façade” that will simply call out to the existing
infrastructure, which I can eventually replace as time progresses. This
gives me the testability advantages of Prism without having to rewrite the
application, which would be a costly and time consuming task.
10. Moving Forward
• Let’s focus on the Policy aspects of the
application.
• next step create a Policy module containing
the PolicyModule, a PolicyService,
PolicyTreeView, PolicyTreeViewModel and a
PolicyController, which will handle the
interactions between the different views of a
policy (when I get that far).
11. Creating a Policy Module
• Each of these classes implements an interface,
which enables me to easily mock these
implementations to test specific aspects of the
application.
• At this stage implementations are very simple in
that they just initialize the relevant Views,
ViewModels, etc.
• The View itself is simply a UserControl that
contains a root Grid element with a background.
The important thing is to get it loaded and
displayed first.
12. Adding Definition
• In the application's shell, the existing user control
was removed and replaced with the following
region definition.
– <ContentControl x:Name="_navigation"
cal:RegionManager.RegionName="{x:Static
inf:RegionNames.Navigation}" DockPanel.Dock="Left" />
• The "cal" XML namespace resolves to
"http://www.codeplex.com/CompositeWPF" and
the "inf" XML namespace resolves to an
infrastructure assembly that contains constants
for the region names.
13. Policy Controller Details
• The PolicyController class retrieves the relevant region that is
the destination of the View and adds the View for the
associated ViewModel to that region and then activates it as
shown below.
public void Run()
{
IRegion region =
this._regionManager.Regions[RegionNames.Navigation];
region.Add(this._policyTreeViewModel.View);
region.Activate(this._policyTreeViewModel.View);
}
• The call to the Activate method is essential if you want to be able to see your
View. Until the Activate method is called, you will not be able to see your View.
14. Policy Controller Continued..
• The Run method of the PolicyController is called in the Initialize method of the PolicyModule after
registering the required views and services, as shown in the following code example.
{
// NOTE: The ContainerControlledLifetimeManager ensures that the same
// instance is returned by any call to Resolve or ResolveAll.
this._container.RegisterType<IPolicyService, PolicyService>(new
ContainerControlledLifetimeManager());
this._container.RegisterType<IPolicyController, PolicyController>(new
ContainerControlledLifetimeManager());
this._container.RegisterType<IProjectTreeView, PolicyTreeView>();
this._container.RegisterType<IPolicyTreeViewModel, PolicyTreeViewModel>();
}
#endregion
Private Methods
#region
IModule Members public void Initialize()
{ RegisterViewsAndServices();
IPolicyController controller = this._container.Resolve<IPolicyController>();
controller.Run(); }
#endregion
16. Modules and Services
• in a composite application built using the CAL, the bulk of the application logic lives in the modules.
• MessagesModule provides related messsages for each policy that is selected.
• PolicyModule provides real-time information on the accounts, for the selected accounts.
• AccountsModule provides a Watch Module that displays a list of accounts you are working with.
• ListModule displays the list of policies in which you an account has and allows you to perform appropriate transactions.
• Using a region removes the need for the module to have any specific reference to the UI or have any knowledge of how the views
injected will be laid out and displayed.
Special thanks to MSDN magazine for letting me re-use this cool diagram.. From their article:
http://msdn.microsoft.com/en-us/magazine/cc785479.aspx
17. Updates
• CAL includes a Region class that is basically a handle that wraps these locations
together.
• The Region class contains a Views property that is a read-only collection of the views
to be displayed within the region.
• Views are added to the region by calling the region's add method.
• The Views property actually contains a generic collection of objects; it is not limited to
containing only UIElements.
• This collection implements INotifyPropertyCollectionChanged so that the UIElement
associated with the region can bind to it and observe changes.
18. Regions and Registration
• Thanks to the rich template support in WPF, you can actually add models directly to the
region. That model can then have an associated Data-Template defined for it that will define
the rendering for the model. If the item added is a UIElement or a user control, then WPF will
just render it as is. This means that if you have a region that is a tab of open policies, you can
sadd the PolicyModel or PolicyPresentation-Model to the region and then define a custom
DataTemplate to control the display rather than having to create a custom PolicyView user
control.
• Regions can be registered in two ways. The first way is defined in XAML by annotating a
UIElement with a RegionName attached property.
• Once a region has been defined via XAML, it will automatically be registered at run time with
RegionManager, one of the composition services registered by the bootstrapper.
RegionManager is essentially a Dictionary where the key is the name of the region and the
value is an instance of the IRegion interface. The RegionManager attached property uses a
RegionAdapter to create this instance.
• CAL ships with three region adapters that are registered by the bootstrapper—
ContentControlRegionAdapter, ItemsControlRegionAdapter, and SelectorRegionAdapter.
Adapters are registered with a RegionAdapterMappings class. Adapters all inherit from
RegionAdapterBase, which implements the I-RegionAdapter interface.
19. Region Adapters
• ItemsControlRegionAdapter- How the adapter itself is implemented depends
completely on the type of UIElement to which it is being adapted. In
ItemsControlRegionAdapter, the bulk of its implementation is in the Adapt method.
• The Adapt method accepts two parameters. The first parameter is an instance of the
Region class itself that Region-Manager creates.
• The second parameter is the UIElement that represents the region. The Adapt method
performs the relevant plumbing to ensure that the region works with the element.
• In the case of an ItemsControl, the adapter automatically removes any child items from
the ItemControl itself and then adds them to the region. The region's Views collection
is then bound to the ItemsSource of the control.
• The second method overridden is CreateRegion, which returns a new AllActiveRegion
instance.
• Regions can contain views that are active or inactive. In the case of the ItemsControl,
all of its items are active all the time because it does not have a notion of selection.
However, in the case of other types of regions, such as Selector, only one item is
selected at a time.
• A view can implement the IActiveAware interface so that it is notified by its region
that it is selected. Whenever the view is selected, it will have its IsSelected property set
to true.
20. More Region Adapters
• Once the region has been defined, it can be accessed from any class within the application by
grabbing hold of the Region-Manager service.
• The common way to do this in a CAL application is to have the dependency injection
container inject the RegionManager into the constructor of the class that needs it. To add a
view or model to a region, simply call the region's Add method. When you add a view, you
can pass an optional name:
_regionManager.Regions["MainRegion"].Add( somePresentationModel,
"SomeView");
• You can later use that name to retrieve the view from the region by using the region's
GetView method.
21. Local Regions
• There is only one RegionManager instance in your application,
thereby making every region globally scoped.
• This addresses a wide set of scenarios, but there are situations
where you may want to define a region that exists only at a
particular scope.
• An example of where you might want to do this is when your
application has a view for a account/policy where multiple
instances of the view can be displayed at the same time.
• If these views are fairly complex, they behave like mini-shells or
CompositeViews. In these cases, you may want each view to have
its own regions, as the shell does.
• The CAL allows you to define a local RegionManager for a view so
that any regions defined within it or its child views are
automatically registered in that local region.
22. Injection
• The UI Composition quickstart included with the guidance illustrates this employee scenario.
– http://msdn.microsoft.com/en-us/library/dd458809.aspx
• In the quickstart there is an employee list. As you click on each employee, you see the
associated employee detail.
• For each employee selection, a new EmployeeDetailsView is created for that employee and
added to the DetailsRegion .
• This view contains a local TabRegion, into which the EmployeesController injects a
ProjectListView in its OnEmployeeSelected method.
23. More Injection
• The region is rendered as a TabControl and contains both static and dynamic content. The General and Location tabs are
statically defined within the XAML. The Current Projects tab, however, has its views injected.
• You can see in the code that a new RegionManager instance is returned from the detailsRegion.Add method. Also notice
that I am using the overload of Add that passes in a name for the view and sets the createRegionManagerScope parameter
to true. Doing this creates a local RegionManager instance that will be used for any regions defined in the children. The
TabRegion itself is defined in the XAML of the EmployeeDetailsView:
<TabControl AutomationProperties.AutomationId="DetailsTabControl"
cal:RegionManager.RegionName="{x:Static local:RegionNames.TabRegion}" .../>
24. Benefits
• Using local regions provides an additional benefit even if you are not using instance regions.
• You can use them for defining a top-level boundary so that a module does not automatically
expose its regions to the rest of the world.
• To do this, add the top-level view for that module into a region and specify for it to have its own
scope.
• Without views you would have no need for a composite. Views are the single most important
element that you will build within your composite apps, as they are the gateway for your users to
the world of functionality that your application provides.
• Views are typically the screens of your application. Views can contain other views, thereby
becoming composite views. Another use of views is for menus and toolbars.
• WPF supports a much richer notion of a View than what was the convention in the Windows Forms
world. In Windows Forms you were basically restricted to using controls as your visual
representation.
• In WPF, this model is still supported and you can create custom user controls for representing your
different screens.
• Views are typically the screens of your application. Views can contain other views, thereby
becoming composite views. Another use of views is for menus and toolbars. In our application, for
example, the ContainerBottom.xaml Toolbar is a view that contains buttons for operations that
work like normal system ones such as Submit, Cancel, Submit All, and Cancel All.
25. Using Models (Code) Instead
• Another approach is to use models. WPF will allow you to bind any model to the UI and then use a
DataTemplate to render it.
• Templates are rendered recursively, meaning that if a template renders an element that binds to a
property of the model, that property will be rendered using a template if it is available.
• WPF supports a much richer notion of a View than what was the convention in the Windows Forms
world. In Windows Forms you were basically restricted to using controls as your visual
representation. In WPF, this model is still supported and you can create custom user controls for
representing your different screens. If you look throughout the CAL sample application, this is the
primary mechanism employed for defining views.
• Another approach is to use models. WPF will allow you to bind any model to the UI and then use a
DataTemplate to render it. Templates are rendered recursively, meaning that if a template renders
an element that binds to a property of the model, that property will be rendered using a template
if it is available.
• Everything starts with the Employee-DetailsPresentationModel. Its template declares that it should
be rendered as a TabControl. As part of the template, it binds the TabControl's ItemsSource to the
EmployeeDetailsPresentationModel's EmployeeDetails collection property. This collection is
populated with two pieces of information when the Employee details are constructed:
public EmployeesDetailsPresentationModel()
{ EmployeeDetails = new ObservableCollection<object>();
EmployeeDetails.Insert(0, new HeaderedEmployeeData());
EmployeeDetails.Insert(1, new EmployeeAddressMapUrl()); ...
27. A Details View Detailed
• Did you notice the details view we just looked at is one big template inside a
resource dictionary??
• In the sample, A separate tab will be rendered for each item in the collection. As
the first item gets rendered, WPF will use the DataTemplate specified for
HeaderedEmployeeData.
• The HeaderedEmployeeData model contains the employee name and contact info.
Its associated template renders the model as a series of labels for displaying the
information.
• The second item will get rendered using the template specified for
EmployeeAddressMapUrl, which in this case will render a frame that contains a
Web page with a map of where the employee lives.
• What’s new here is that a view as you previously knew it only existed at run time
through the combination of the model and its associated template. You can also
implement a hybrid of both approaches, where you have user controls that have
controls within them that are then bound to models that are rendered through
templates.
28. UI: Presentation Model and
Supervising Controller
• The Presentation Model pattern assumes a model that
contains both the behavior and the data for the UI. The
view then projects the presentation model's state "onto
the glass."
• Behind the scenes the model interacts with business and
domain models. The model also includes additional state
information such as the selected item or whether an
element is checked. The view then binds to the
Presentation Model directly and renders it.
• The rich support in WPF for data binding, templates, and
commands makes the Presentation Model pattern almost a
nuclear option for development with anything else.
29. Communication Challenges
• The model is the data; it is more often than not a business object. The view is a UIElement to which the
model directly binds. And lastly, the presenter is a class that contains the UI logic. In this pattern, the view
contains very little logic other than delegating to the presenter and responding to callbacks from the
presenter to perform simple actions including either displaying or hiding a control.
• One of the challenges that arise when implementing separated presentation is the communication
between the view and the presentation model or presenter. There are several approaches to handling
this.
• One often implemented is having event handlers in the view that either directly call or raise events to the
presentation model or presenter. The same UIElements that initiate calls to the presenter often have to be
enabled or disabled in the UI based on state changes or permissions. This requires the view to have
methods that can be used to call it back in order to disable those elements.
30. And More Challenges..
• One of the challenges that arise when implementing separated presentation is the
communication between the view and the presentation model or presenter. There are
several approaches to handling this.
• One that is often implemented is having event handlers in the view that either directly call or
raise events to the presentation model or presenter. The same UIElements that initiate calls
to the presenter often have to be enabled or disabled in the UI based on state changes or
permissions. This requires the view to have methods that can be used to call it back in order
to disable those elements.
• Another approach is to use WPF commands. Commands provide a clean way of addressing
these situations without requiring all the back-and-forth delegation logic. Elements in WPF
can bind to commands to handle both execution logic and enabling or disabling elements.
When a UIElement is bound to a command, it will automatically be disabled whenever the
command's Can-Execute property is false. Commands can be bound declaratively in XAML.
• WPF provides RoutedUICommands. Using these commands requires a handler for the
Execute and Can-Execute methods within the view's codebehind—which means that code
modification is still required for the back-and-forth communication. RoutedUICommands
also have other constraints, such as requiring the receiver to be in WPF's logical tree, a
constraint that is problematic for building composite applications.
31. Icommand and Delgate-Command to
the Rescue
• WPF provides the ICommand interface. This will bind to any
command that implements it. This means you can create custom
commands fullfill all of your needs, and you don't need to touch the
codebehind.
• The downside is that you have to implement custom commands,
such as SaveCommand, Submit-Command, and CancelCommand
yourself in the application.
• The CAL includes new commands such as the Delegate-
Command<T>,which allows you to specify the two delegates for
the Execute and CanExecute methods in the constructor.
• Using this command allows you to wire up views without having to
delegate through methods defined in the view itself and without
having to create custom commands for each action.
32. Using a Delegate Command in the
Accounts Watchlist
• WatchListService uses this command for
adding items to the watch list
public WatchListService(IMarketFeedService
marketFeedService)
{this.marketFeedService = marketFeedService;
WatchItems = new ObservableCollection<string>();
AddWatchCommand = new DelegateCommand<string>(AddWatch);
}
33. Publish and Subscribe
• In addition to routing commands between the view
and a presenter or presentation model, there are other
types of communication, such as event publication,
that need to be handled.
• In these cases, the publisher is completely decoupled
from the subscriber.
• For example, our “legacy” application needs to have a
module that exposes a Web service endpoint that
receives notifications from the server. Once that
notification is received, it needs to fire an event to
which components within the same or other modules
can subscribe.
34. Events
• To support this functionality, the CAL has an EventAggregator service that is registered with the
container. Using this service, which is an implementation of the Event Aggregator pattern,
publishers and subscribers can communicate in a loosely coupled fashion.
• The EventAggregator service contains a repository of events that are instances of the abstract
EventBase class. The service has one GetEvent<TEventType> method for retrieving event
instances.
• The CAL includes the CompositeWPFEvent<TPayload> class that inherits EventBase and
provides specific support for WPF. This class uses delegates rather than full .NET events for
publishing. Under the hood it uses a DelegateReference class that, by default, functions as a weak
delegate (see msdn.microsoft.com/library/ms404247). This allows subscribers to be garbage
collected even when they do not explicitly unsubscribe.
• The CompositeWPFEvent class contains Publish, Subscribe, and Unsubscribe methods. Each uses
the generic type information of the event to ensure that the publisher passes the correct
parameters (TPayload) and the Subscriber property receives them (Action<TPayload>).
• The Subscribe method allows passing in a ThreadOption that can be set to PublisherThread,
UIThread, or BackgroundThread. This option determines on which thread the subscribing delegate
will be invoked. Also, the Subscribe method is overloaded to allow passing in a Predicate<T>
filter so that the subscriber only gets notified of the event if the filter is satisfied.
35. Event Aggregation
• In our app, the EventAggregator should be
used for broadcasting whenever a policy item
or an account is selected in the positions
screen. The messages module subscribes to
this event and displays messages for the
account or policy.
• public class AccountSelectedEvent : CompositeWpfEvent<string>
{ }
36. Defining an Event
• The event is defined in our application’s infrastructure assembly, to which all modules in our
application reference.
public void Run()
{
this.regionManager.Regions[“MessagesRegion"].Add( articlePresentationModel.View);
eventAggregator.GetEvent<AccountSelectedEvent>().Subscribe( ShowNews,
ThreadOption.UIThread);
}
public void ShowNews(string companySymbol)
{
articlePresentationModel.SetAccount(companyAccount);
}
Another module's Controller then subscribes to this event in its Run method:
private void View_CompanySymbolSelected(object sender, DataEventArgs<string> e)
{ _trendLinePresenter.OnCompanySymbolSelected(e.Value);
EventAggregator.GetEvent<TickerSymbolSelectedEvent>().Publish( e.Value); }
The presentation model then fires the event whenever an account is selected.
37. Composite Extensions to support
Non-UI Elements and processes
• Brian Noyes’ Composite Extensions: If you like the modularity and publish
-subcribe events capabilities in Prism and would like to be able to do those same
things to adapt your legacy .NET application here are some extensions and add-
ons that are must haves.
• These extensions allow you to use the modular loading patterns and capabilities of
Prism as well as the pub/sub events in a Windows Forms application, or any other
kind of application (even console apps, WCF services, etc.).
• KEY ELEMENTS (staying the same):
– A CompositeEvent class that has all the same capability as the CompositePresentationEvent
class in Prism2, but is not tied to the WPF libraries at all.
– For the UI thread dispatching capability, it uses the SynchronizationContext class (which is
used under the covers by both WPF and Windows Forms, so this class will also work with
WPF).
– A SimpleUnityBootstrapper class that removes the tie to WPF in the bootstrapper by
removing the creation of the shell and the region adapter stuff.
• Check out Brian Noyes’ Downloads and Videos and Demos at DNR.TV
• http://www.dnrtv.com/default.aspx?showNum=132
39. More Tools- Calcium
• Introduction
• Calcium is a WPF composite application toolset that
leverages the Composite Application Library. It
provides much of what one needs to rapidly build a
multifaceted and sophisticated modular application.
• Calcium consists of a client application and server
based WCF services, which allow interaction and
communication between clients. Out of the box,
Calcium comes with a host of modules and services,
and an infrastructure that is ready to use in your next
application.
41. Calcium Features
• Duplex messaging services for interacting with the user from the client or
server using the same API. Interact with the user using Message Boxes
from the server!
• Module Manager for enabling or disabling of modules at runtime.
• A User Affinity module that assists collaboration with other users of the
application.
• A Command Service to associate WPF ICommands with content interfaces
that only become active when an active view or viewmodel implements
the interface.
• Region Adapters for ToolBars and Menus.
• Client-server logging ready to work out-of-the-box.
• Includes modules, such as a Web Browser, Text Editor, Output Window,
and many more.
• Tabbed interface with dirty file indication (reusable across modules).
42. Calcium
• Calcium is a WPF composite application toolset that leverages the Composite
Application Library. It provides much of what one needs to rapidly build a
multifaceted and sophisticated modular application.
Calcium consists of a client application and server based WCF services, which allow
interaction and communication between clients. Out of the box, Calcium comes
with a host of modules and services, and an infrastructure that is ready to use in
your next application.
• Get it today at: http://calcium.codeplex.com/
43. Porting the Legacy
Application to
MVVM/Composite
Application Guidance
By Don Burnett