This article is the first in a series which takes a detailed look at generating strong types, in languages such as C# and Java, from W3C XSD schemas.
W3C Schema definitions are very much active in business areas such as Finance, Air Transportation, government messaging, hospitality and international goods and services
This article describes the functionality within Schema Studio which allows a user to establish the landscape of dependent types for a selected top-level type in a Schema.
Secure software development has become a priority for all organizations whether they build their own software or outsource. And code analysis is becoming the de facto choice to introduce secure development as well as measure inherent software risk.
This document discusses implementing single sign-on for a multi-tenant SaaS application using SAML. It aims to address the issue of multi-tenancy in SaaS applications by allowing users to authenticate using their identity provider credentials rather than separate application credentials. The author implemented a loosely coupled SAML-based single sign-on solution for a SaaS application deployed on public cloud. This included configuring the application as a SAML service provider, importing identity provider metadata, and evaluating the solution to reduce storage and communication costs compared to conventional username/password authentication.
- The document discusses an internship report on iOS technology. The intern installed Xcode 6.4 and learned Objective-C programming. They built an iOS application using Xcode and gathered requirements from the design team. They also worked on product documentation.
The document discusses methods for estimating the effort required for software tasks and projects. It describes traditional methods like estimating based on lines of code or function points. It provides details on estimating the life cycle based on the development stage and calculating lines of code through direct estimation or function point analysis with backfiring to convert to lines of code. Factors and tables are given for estimating effort based on lines of code and programming languages.
The document summarizes a security analysis report of the LinkedIn website performed by Minded Security using the DOMinatorPro Enterprise security scanner. The analysis found a reflected DOM-based cross-site scripting (XSS) vulnerability that allows an attacker to inject arbitrary HTML and JavaScript into the browser DOM context of LinkedIn. The vulnerability is due to unsanitized user input being used to generate HTML output without encoding. A proof-of-concept exploit is provided to demonstrate the vulnerability by triggering a popup alert on the victim's browser when a specially crafted URL is visited while logged into LinkedIn.
This document describes a UI testing pattern using React, Material-UI, BDD with Cucumber, and Kotlin/Selenide. It utilizes the Se34 page object generator to generate page object classes from metadata. This separates page representation from test logic for improved maintenance. Tests are defined in BDD style and cover use cases like login, account creation, and password recovery. Page objects and step definitions enable clear and maintainable automation code. Test results are output to the console.
The document discusses using DITA (Darwin Information Typing Architecture) for technical documentation. It describes how DITA allows structuring content into modular topics and maps to generate information. DITA supports features like content reuse through conditions, and multi-lingual content through language tags. Content management systems like SDL LiveContent can store and publish DITA content, including maintaining common information through globally unique IDs for topics in different languages. This allows technical documentation to be delivered to customers in multiple languages.
This article describes the functionality within Schema Studio which allows a user to establish the landscape of dependent types for a selected top-level type in a Schema.
Secure software development has become a priority for all organizations whether they build their own software or outsource. And code analysis is becoming the de facto choice to introduce secure development as well as measure inherent software risk.
This document discusses implementing single sign-on for a multi-tenant SaaS application using SAML. It aims to address the issue of multi-tenancy in SaaS applications by allowing users to authenticate using their identity provider credentials rather than separate application credentials. The author implemented a loosely coupled SAML-based single sign-on solution for a SaaS application deployed on public cloud. This included configuring the application as a SAML service provider, importing identity provider metadata, and evaluating the solution to reduce storage and communication costs compared to conventional username/password authentication.
- The document discusses an internship report on iOS technology. The intern installed Xcode 6.4 and learned Objective-C programming. They built an iOS application using Xcode and gathered requirements from the design team. They also worked on product documentation.
The document discusses methods for estimating the effort required for software tasks and projects. It describes traditional methods like estimating based on lines of code or function points. It provides details on estimating the life cycle based on the development stage and calculating lines of code through direct estimation or function point analysis with backfiring to convert to lines of code. Factors and tables are given for estimating effort based on lines of code and programming languages.
The document summarizes a security analysis report of the LinkedIn website performed by Minded Security using the DOMinatorPro Enterprise security scanner. The analysis found a reflected DOM-based cross-site scripting (XSS) vulnerability that allows an attacker to inject arbitrary HTML and JavaScript into the browser DOM context of LinkedIn. The vulnerability is due to unsanitized user input being used to generate HTML output without encoding. A proof-of-concept exploit is provided to demonstrate the vulnerability by triggering a popup alert on the victim's browser when a specially crafted URL is visited while logged into LinkedIn.
This document describes a UI testing pattern using React, Material-UI, BDD with Cucumber, and Kotlin/Selenide. It utilizes the Se34 page object generator to generate page object classes from metadata. This separates page representation from test logic for improved maintenance. Tests are defined in BDD style and cover use cases like login, account creation, and password recovery. Page objects and step definitions enable clear and maintainable automation code. Test results are output to the console.
The document discusses using DITA (Darwin Information Typing Architecture) for technical documentation. It describes how DITA allows structuring content into modular topics and maps to generate information. DITA supports features like content reuse through conditions, and multi-lingual content through language tags. Content management systems like SDL LiveContent can store and publish DITA content, including maintaining common information through globally unique IDs for topics in different languages. This allows technical documentation to be delivered to customers in multiple languages.
This document discusses principles for building application front-ends in a service-oriented world. It proposes a Service-Oriented Front-End Architecture (SOFEA) style with the following key principles: 1) Decouple the processes of application download, presentation flow, and data interchange; 2) Presentation flow should be driven by client-side components and managed within the client; 3) Data interchange between tiers should follow common standards to avoid integrity issues and support rich data. Adhering to these principles can help integrate presentation tiers with increasingly service-oriented backends.
Design Patterns in Electronic Data ManagementGlen Alleman
The concept of a design pattern is based on the seminal work of Christopher Alexander
This White Paper describes the design patterns that are applicable to the Electronic Document Management domain. These include Management of Change, Hypermedia Navigation, Aggregated Relationships, Object to Relational Database Mapping, Compound Documents, and Data Entry Management.
This is a course about embedded systems programming. Embedded systems are everywhere today, including just to name a few the thermostats that control a building's temperature, the power-steering controller in modern automobiles, and the control systems in charge of jet engines. The prerequisites for reading this ebook are: knowledge about computer and processors architecture, Ada programming language.
This document discusses JavaScript design patterns and module loading strategies like AMD and CommonJS. It begins by defining what design patterns and antipatterns are. It then covers different types of design patterns like creational, structural, and behavioral patterns. A large portion of the document is dedicated to explaining module loading strategies like Asynchronous Module Definition (AMD) using RequireJS and CommonJS. It provides examples of how to define AMD modules using RequireJS and how to write CommonJS style modules.
Java TechTalk "Spring boot made life easier with Kubernetes and Microservices"GlobalLogic Ukraine
This document provides an overview of using Spring Boot, Kubernetes, and microservices. It discusses the popularity of microservices and their pros and cons. It introduces Domain Driven Design (DDD) and how it differs from a more traditional approach by defining bounded contexts for subdomains. The document then provides a quick introduction to Kubernetes and Spring Boot. It describes a typical microservices architecture with services corresponding to domains and communication via REST APIs. Finally, it mentions a sample project using Spring Boot, Docker, and Minikube.
The document provides an overview of key-value stores and discusses CouchDB, Tokyo Cabinet, Redis, and Cassandra as alternatives to relational databases for web applications. It describes each system's features and interface to the Ruby programming language. CouchDB uses JavaScript for generating views and stores schema-less data accessed via HTTP/JSON. Tokyo Cabinet supports hashtable, B-tree, and table modes and is used by Mixi, a Japanese social network. Redis is an in-memory key-value store focused on performance. Cassandra is a distributed, structured key-value store developed by Facebook based on Amazon's Dynamo database.
This document provides an overview and instructions for customizing AutoCAD 2008. It covers topics such as organizing customization files, creating custom commands, linetypes, and hatch patterns, customizing the user interface through menus and toolbars, using macros and AutoLISP, and more. The document is intended as a guide for customizing AutoCAD to meet company or individual needs and standards.
This document provides information for developers wishing to develop applications using the MySQL Cluster storage engine APIs. It describes the low-level C++ NDB API, the C MGM API for controlling management servers, and the MySQL Cluster Connector for Java. The guide includes concepts, terminology, class and function references, examples, common problems and tips for using these APIs to develop applications. It also contains information about NDB internals that may be of interest to developers working with MySQL Cluster.
This master's thesis investigates using the OSLC standard to target the documentation requirements of ISO 26262 for automotive safety-critical systems. The thesis focuses on part 6 clause 8 of ISO 26262 regarding software unit design and implementation. It proposes creating an OSLC tool-chain infrastructure for sharing safety information fragments to generate a safety case. The thesis models regulatory and company requirements, defines an OSLC domain specification, and evaluates RDF constraint languages for shaping safety resources. The goal is to provide a methodological approach for semantically representing ISO 26262 work products to enable traceability and documentation for a safety case. A case study models a software unit as a proof of concept.
This document is Karthik Gomadam's dissertation submitted in partial fulfillment of the requirements for a Doctor of Philosophy degree from Wright State University. The dissertation addresses problems related to semantics enriched service environments, including service description, discovery, data mediation, and dynamic configuration. It proposes techniques to add semantic metadata to RESTful services and resources on the web, an algorithm for service discovery and ranking, and methods for aiding data mediation and dynamic configuration. The dissertation also examines applying service-oriented principles to social and human computation.
.NET is designed to solve problems that have plagued programmers in the past like incompatibilities between programming languages and technologies. It provides a common language runtime and type system that allows different languages to work together. The .NET Framework handles many common programming tasks like serialization automatically through metadata and provides a large class library for common functions.
The document describes an honors thesis presented by Rhea Stadick that implemented the Elliptic Curve Digital Signature Algorithm (ECDSA) in Java using the NIST prime elliptic curves over GF(p). The thesis created a Java applet that provides the functionality of ECDSA including key generation, signature generation, and signature verification. The applet was embedded in a website for public use. The implementation details and analysis of the ECDSA applet code are discussed.
blue-infinity White Paper on JavaFX by Jan Stenvallblue-infinity
JavaFX is a mature Java-based platform for building desktop, mobile and embedded UI applications. It provides over 50 UI controls and components, support for CSS styling, animations and effects. JavaFX applications can be developed in Java or dynamic languages like Groovy and Scala that compile to Java bytecode. While tools for visual UI design are still being developed, JavaFX leverages the large Java developer community and can reuse existing Java code and libraries.
Demystifying the Cloud – Drawing the Lines between Technologies and ConceptsNewCo
I was contacted by Kevin Arnot after he found my video on the cloud ( "What is the Cloud (now with pictures!)? - http://bit.ly/14ZsFnX ) on YouTube. We had a great conversation much of which ended up in his final paper. I'm happy to report that I did not lead him astray - he received a grade of 4.0 out of 4.0 (great work Kevin)!
By the way - don't be scared-off by any German you may come across. During the time he wrote this paper Kevin, who is German, was studying in the US. Therefore, the bulk of the paper (including all the useful info) is in English.
Here's the paper's abstract:
In recent years the term Cloud has become popular in the world of technology. It is used to describe many different Information Technology offerings, but people are adapting this word without truly understanding it. “Demystifying the Cloud – Drawing the Lines between Technologies and Concepts” by Kevin Arnot takes a look at many levels of the Cloud and gives a comprehensive overview of the technologies and ideas that make it a paradigm shift. The author analyzes the term methodically by leveraging appropriate information from the Internet as well as from experts. An important mile- stone in understanding the Cloud accurately is differentiating between its components. These include: underlying technologies, the three Cloud Service Models (SaaS, IaaS and PaaS) and how it is deployed, publically or privately. The result is to understand that a Cloud can be composed in different ways and therefore serves exactly the needs of its users. Furthermore, the author describes challenges that individuals and busi- nesses have to deal with equally and reviews possible solutions. Cloud technology will continue to evolve; however, the future business value of the term “Cloud” will depend on how companies continue using or misusing it.
p.s. I did receive the OK from Kevin to post his paper online.
This document provides an introduction to creating a new language for a Service Creation Environment (SCE) using Sixlabs' Generador de Ambientes de Alta Productividad (GAAP). It discusses key concepts for building an SCE like properties, dialogs, entities and functional code. It also covers the tradeoff between productivity and flexibility in entity design. The document then demonstrates creating a new Logo language for an SCE, including defining entities, creating dialogs and generating functional code templates using XSLT.
This document discusses how to build customizable Oracle ADF business applications using Oracle Metadata Services (MDS). MDS allows applications to be customized for personalization, rebranding, and customization purposes. It manages customizations by layering changes on top of a base application. The document covers how MDS works, how to configure ADF applications to use MDS for change persistence, and how to implement seeded customizations for user roles. It provides examples and best practices for developing customizable applications with MDS.
SoftCloud: A Tool for Visualizing Software Artifacts as Tag Clouds.pdfRa'Fat Al-Msie'deen
Software artifacts visualization helps software developers to manage the size and complexity of the software system. The tag cloud technique visualizes tags within the cloud according to their frequencies in software artifacts. A font size of the tag within the cloud indicates its frequency within a software artifact, while the color of a tag within the cloud uses just for aesthetic purposes. This paper suggests a new approach (SoftCloud) to visualize software artifacts as a tag cloud. The originality of SoftCloud is visualizing all the artifacts available to the software program as a tag cloud. Experiments have conducted on different software artifacts to validate SoftCloud and demonstrate its strengths. The results showed the ability of SoftCloud to correctly retrieve all tags and their frequencies from available software artifacts.
DDS Advanced Tutorial - OMG June 2013 Berlin MeetingJaime Martin Losa
An extended, in-depth tutorial explaining how to fully exploit the standard's unique communication capabilities.Presented at the OMG June 2013 Berlin Meeting.
Users upgrading to DDS from a homegrown solution or a legacy-messaging infrastructure often limit themselves to using its most basic publish-subscribe features. This allows applications to take advantage of reliable multicast and other performance and scalability features of the DDS wire protocol, as well as the enhanced robustness of the DDS peer-to-peer architecture. However, applications that do not use DDS's data-centricity do not take advantage of many of its QoS-related, scalability and availability features, such as the KeepLast History Cache, Instance Ownership and Deadline Monitoring. As a consequence some developers duplicate these features in custom application code, resulting in increased costs, lower performance, and compromised portability and interoperability.
This tutorial will formally define the data-centric publish-subscribe model as specified in the OMG DDS specification and define a set of best-practice guidelines and patterns for the design and implementation of systems based on DDS.
Digibury: Getting your web presence mobile ready - David WalkerLizzie Hodgson
This document discusses how to make websites responsive using CSS frameworks. It explains that mobile usage is growing and users expect mobile-friendly sites. CSS frameworks like Foundation can help bridge skills gaps by providing preset responsive grids and functionality. The document outlines the minimum requirements for responsive design like fluid images and media queries. It provides examples of how to use Foundation's grid system and other tools to create responsive layouts and images. While frameworks have pros like speeding development, they also have cons like restricting freedom; responsive design requires going beyond simple layout changes.
This article looks at a specific "record-and-playback" testing tool, TestIm, and finds that it performs surprisingly well. It seems that the long-held view that such approaches are unreliable and lead to flaky tests is unfounded. The Phoenix Rises ...
This document discusses principles for building application front-ends in a service-oriented world. It proposes a Service-Oriented Front-End Architecture (SOFEA) style with the following key principles: 1) Decouple the processes of application download, presentation flow, and data interchange; 2) Presentation flow should be driven by client-side components and managed within the client; 3) Data interchange between tiers should follow common standards to avoid integrity issues and support rich data. Adhering to these principles can help integrate presentation tiers with increasingly service-oriented backends.
Design Patterns in Electronic Data ManagementGlen Alleman
The concept of a design pattern is based on the seminal work of Christopher Alexander
This White Paper describes the design patterns that are applicable to the Electronic Document Management domain. These include Management of Change, Hypermedia Navigation, Aggregated Relationships, Object to Relational Database Mapping, Compound Documents, and Data Entry Management.
This is a course about embedded systems programming. Embedded systems are everywhere today, including just to name a few the thermostats that control a building's temperature, the power-steering controller in modern automobiles, and the control systems in charge of jet engines. The prerequisites for reading this ebook are: knowledge about computer and processors architecture, Ada programming language.
This document discusses JavaScript design patterns and module loading strategies like AMD and CommonJS. It begins by defining what design patterns and antipatterns are. It then covers different types of design patterns like creational, structural, and behavioral patterns. A large portion of the document is dedicated to explaining module loading strategies like Asynchronous Module Definition (AMD) using RequireJS and CommonJS. It provides examples of how to define AMD modules using RequireJS and how to write CommonJS style modules.
Java TechTalk "Spring boot made life easier with Kubernetes and Microservices"GlobalLogic Ukraine
This document provides an overview of using Spring Boot, Kubernetes, and microservices. It discusses the popularity of microservices and their pros and cons. It introduces Domain Driven Design (DDD) and how it differs from a more traditional approach by defining bounded contexts for subdomains. The document then provides a quick introduction to Kubernetes and Spring Boot. It describes a typical microservices architecture with services corresponding to domains and communication via REST APIs. Finally, it mentions a sample project using Spring Boot, Docker, and Minikube.
The document provides an overview of key-value stores and discusses CouchDB, Tokyo Cabinet, Redis, and Cassandra as alternatives to relational databases for web applications. It describes each system's features and interface to the Ruby programming language. CouchDB uses JavaScript for generating views and stores schema-less data accessed via HTTP/JSON. Tokyo Cabinet supports hashtable, B-tree, and table modes and is used by Mixi, a Japanese social network. Redis is an in-memory key-value store focused on performance. Cassandra is a distributed, structured key-value store developed by Facebook based on Amazon's Dynamo database.
This document provides an overview and instructions for customizing AutoCAD 2008. It covers topics such as organizing customization files, creating custom commands, linetypes, and hatch patterns, customizing the user interface through menus and toolbars, using macros and AutoLISP, and more. The document is intended as a guide for customizing AutoCAD to meet company or individual needs and standards.
This document provides information for developers wishing to develop applications using the MySQL Cluster storage engine APIs. It describes the low-level C++ NDB API, the C MGM API for controlling management servers, and the MySQL Cluster Connector for Java. The guide includes concepts, terminology, class and function references, examples, common problems and tips for using these APIs to develop applications. It also contains information about NDB internals that may be of interest to developers working with MySQL Cluster.
This master's thesis investigates using the OSLC standard to target the documentation requirements of ISO 26262 for automotive safety-critical systems. The thesis focuses on part 6 clause 8 of ISO 26262 regarding software unit design and implementation. It proposes creating an OSLC tool-chain infrastructure for sharing safety information fragments to generate a safety case. The thesis models regulatory and company requirements, defines an OSLC domain specification, and evaluates RDF constraint languages for shaping safety resources. The goal is to provide a methodological approach for semantically representing ISO 26262 work products to enable traceability and documentation for a safety case. A case study models a software unit as a proof of concept.
This document is Karthik Gomadam's dissertation submitted in partial fulfillment of the requirements for a Doctor of Philosophy degree from Wright State University. The dissertation addresses problems related to semantics enriched service environments, including service description, discovery, data mediation, and dynamic configuration. It proposes techniques to add semantic metadata to RESTful services and resources on the web, an algorithm for service discovery and ranking, and methods for aiding data mediation and dynamic configuration. The dissertation also examines applying service-oriented principles to social and human computation.
.NET is designed to solve problems that have plagued programmers in the past like incompatibilities between programming languages and technologies. It provides a common language runtime and type system that allows different languages to work together. The .NET Framework handles many common programming tasks like serialization automatically through metadata and provides a large class library for common functions.
The document describes an honors thesis presented by Rhea Stadick that implemented the Elliptic Curve Digital Signature Algorithm (ECDSA) in Java using the NIST prime elliptic curves over GF(p). The thesis created a Java applet that provides the functionality of ECDSA including key generation, signature generation, and signature verification. The applet was embedded in a website for public use. The implementation details and analysis of the ECDSA applet code are discussed.
blue-infinity White Paper on JavaFX by Jan Stenvallblue-infinity
JavaFX is a mature Java-based platform for building desktop, mobile and embedded UI applications. It provides over 50 UI controls and components, support for CSS styling, animations and effects. JavaFX applications can be developed in Java or dynamic languages like Groovy and Scala that compile to Java bytecode. While tools for visual UI design are still being developed, JavaFX leverages the large Java developer community and can reuse existing Java code and libraries.
Demystifying the Cloud – Drawing the Lines between Technologies and ConceptsNewCo
I was contacted by Kevin Arnot after he found my video on the cloud ( "What is the Cloud (now with pictures!)? - http://bit.ly/14ZsFnX ) on YouTube. We had a great conversation much of which ended up in his final paper. I'm happy to report that I did not lead him astray - he received a grade of 4.0 out of 4.0 (great work Kevin)!
By the way - don't be scared-off by any German you may come across. During the time he wrote this paper Kevin, who is German, was studying in the US. Therefore, the bulk of the paper (including all the useful info) is in English.
Here's the paper's abstract:
In recent years the term Cloud has become popular in the world of technology. It is used to describe many different Information Technology offerings, but people are adapting this word without truly understanding it. “Demystifying the Cloud – Drawing the Lines between Technologies and Concepts” by Kevin Arnot takes a look at many levels of the Cloud and gives a comprehensive overview of the technologies and ideas that make it a paradigm shift. The author analyzes the term methodically by leveraging appropriate information from the Internet as well as from experts. An important mile- stone in understanding the Cloud accurately is differentiating between its components. These include: underlying technologies, the three Cloud Service Models (SaaS, IaaS and PaaS) and how it is deployed, publically or privately. The result is to understand that a Cloud can be composed in different ways and therefore serves exactly the needs of its users. Furthermore, the author describes challenges that individuals and busi- nesses have to deal with equally and reviews possible solutions. Cloud technology will continue to evolve; however, the future business value of the term “Cloud” will depend on how companies continue using or misusing it.
p.s. I did receive the OK from Kevin to post his paper online.
This document provides an introduction to creating a new language for a Service Creation Environment (SCE) using Sixlabs' Generador de Ambientes de Alta Productividad (GAAP). It discusses key concepts for building an SCE like properties, dialogs, entities and functional code. It also covers the tradeoff between productivity and flexibility in entity design. The document then demonstrates creating a new Logo language for an SCE, including defining entities, creating dialogs and generating functional code templates using XSLT.
This document discusses how to build customizable Oracle ADF business applications using Oracle Metadata Services (MDS). MDS allows applications to be customized for personalization, rebranding, and customization purposes. It manages customizations by layering changes on top of a base application. The document covers how MDS works, how to configure ADF applications to use MDS for change persistence, and how to implement seeded customizations for user roles. It provides examples and best practices for developing customizable applications with MDS.
SoftCloud: A Tool for Visualizing Software Artifacts as Tag Clouds.pdfRa'Fat Al-Msie'deen
Software artifacts visualization helps software developers to manage the size and complexity of the software system. The tag cloud technique visualizes tags within the cloud according to their frequencies in software artifacts. A font size of the tag within the cloud indicates its frequency within a software artifact, while the color of a tag within the cloud uses just for aesthetic purposes. This paper suggests a new approach (SoftCloud) to visualize software artifacts as a tag cloud. The originality of SoftCloud is visualizing all the artifacts available to the software program as a tag cloud. Experiments have conducted on different software artifacts to validate SoftCloud and demonstrate its strengths. The results showed the ability of SoftCloud to correctly retrieve all tags and their frequencies from available software artifacts.
DDS Advanced Tutorial - OMG June 2013 Berlin MeetingJaime Martin Losa
An extended, in-depth tutorial explaining how to fully exploit the standard's unique communication capabilities.Presented at the OMG June 2013 Berlin Meeting.
Users upgrading to DDS from a homegrown solution or a legacy-messaging infrastructure often limit themselves to using its most basic publish-subscribe features. This allows applications to take advantage of reliable multicast and other performance and scalability features of the DDS wire protocol, as well as the enhanced robustness of the DDS peer-to-peer architecture. However, applications that do not use DDS's data-centricity do not take advantage of many of its QoS-related, scalability and availability features, such as the KeepLast History Cache, Instance Ownership and Deadline Monitoring. As a consequence some developers duplicate these features in custom application code, resulting in increased costs, lower performance, and compromised portability and interoperability.
This tutorial will formally define the data-centric publish-subscribe model as specified in the OMG DDS specification and define a set of best-practice guidelines and patterns for the design and implementation of systems based on DDS.
Digibury: Getting your web presence mobile ready - David WalkerLizzie Hodgson
This document discusses how to make websites responsive using CSS frameworks. It explains that mobile usage is growing and users expect mobile-friendly sites. CSS frameworks like Foundation can help bridge skills gaps by providing preset responsive grids and functionality. The document outlines the minimum requirements for responsive design like fluid images and media queries. It provides examples of how to use Foundation's grid system and other tools to create responsive layouts and images. While frameworks have pros like speeding development, they also have cons like restricting freedom; responsive design requires going beyond simple layout changes.
This article looks at a specific "record-and-playback" testing tool, TestIm, and finds that it performs surprisingly well. It seems that the long-held view that such approaches are unreliable and lead to flaky tests is unfounded. The Phoenix Rises ...
This document describes some recent refactoring of the W3C Schema processor which is part of the Schema Studio application. This processor turns Schema definitions into C# strong types ready to use in a development project.
To anyone interested in accelerating their Test Automation work, here's an article that could well help to point the way ahead!
It also covers the production of multi-lingual validation data.
This Article explores the Test Automation challenges associated with the GridGain Control Centre (https://www.gridgain.com/).
The test framework is based on BDD/Selenide/Java/IntelliJ.
The exploratory tests look at five key User Journeys in the application.
The document discusses code generation from an XSD schema containing complex types. It analyzes the ComplexType "AdvResTicketingType" which has a nested structure including elements, sequences, and attributes. The generator represents this structure using an intermediate "Structure Element Repository" format. It generates classes for the complex type and its dependent types, ensuring optional elements and attributes are handled correctly. The generator also produces internal classes to represent sequences and elements within the complex type.
In this article, I take a brief look at a tool which performs, essentially, Record Playback test creation and Execution - TestIm Chrome extension.
I was very pleasantly surprised by what I discovered.
This tool has definitely a place in the Test Automation toolbox, but, in my view, for business-related settings.
This document discusses attribute groups and attributes in XSD schemas. It provides examples of attribute group definitions from the Open Travel schema, including the NegotiatedFareAttributes, DirectAndStopsGroup, and DiscountPricingGroup attribute groups. It describes how an XSD generator handles different attribute group content models, such as those containing simple attributes, simple types with enumerations, and named simple types. Documentation and unit tests for the generated classes corresponding to the example attribute groups are included in appendices.
This article describes how the W3C Schema SimpleType definitions can be transformed through generation to strong-types that can be used directly in development projects.
This document describes a test data value store approach for handling test data needs in behavior-driven development (BDD) automated tests. It involves storing test data in a JSON file organized by feature, scenario, example case, page, and language. The data store is initialized by resolving keys to the current test from Cucumber scenario tags. Test code can then retrieve data values from the store as needed to validate page elements for each test case execution. The approach aims to provide flexibility in retrieving test-dependent data while avoiding cluttering the clean BDD syntax with data tables or excessive scenario outlines.
This article provides a comparison of the Classic (Cucumber/Gherkin) and Technical (Karate/Gherkin) uses of the BDD style. It turns out that they are very complimentary.
Babble article - Test Automation & Text TranslationDavid Harrison
This article shows a pattern for Test Automation that embraces the testing (validation) of web applications that allow different spoken languages (EN, IT etc). It also presents a novel way of writing BDD statements that improves the Test Automation development and maintenance process.
This publication provides an innovative approach to documenting BDD-based test automation projects.
In particular, it introduces the BddDocumenter tool which merges the Business and Developer/(Test Automater) views of a test automation codebase into consistent and fluent documentation. Both the BDD statements and the Step Definition code can be changed as required, the new documentation can be easily regenerated.
The document proposes a data-driven automated testing platform for web services using SoapUI. The platform utilizes Excel files to store test case data, request and response exemplars defined in XML, and Groovy scripts to build requests and validate responses. This allows testing web services in a maintainable and scalable way that is accessible for various roles.
This is the first part of a 3-part series covering Selenium-based test automation in the context of validation, workflow (Specflow), Zalenium and Azure cloud.
The slide deck provides insight into the features of a Selenium-based test automation approach that allows rapid test development and maintenance, such as would be needed in an AGile project context.
This slide pack describes an innovative approach to designing automated tests. This approach bridges the "language" gap that can sometimes exist between test automators/developers and business stakeholders.
This slide-pack describes a prototype application for building contextual documentation from Agile stories. The impact on normal Story writing is minimal, a set of business-related tags form the first line of the Story description.
This slide pack describes the challenges of We application test automation as well as provides a list of items that we would "prefer" to achieve when we automate. Finally, it provides an overview of a novel generative approach that cuts through the challenges, meets the "prefer" list items and allows Selenium-based test automation to be done at Agile speed.
When deliberating between CodeIgniter vs CakePHP for web development, consider their respective strengths and your project requirements. CodeIgniter, known for its simplicity and speed, offers a lightweight framework ideal for rapid development of small to medium-sized projects. It's praised for its straightforward configuration and extensive documentation, making it beginner-friendly. Conversely, CakePHP provides a more structured approach with built-in features like scaffolding, authentication, and ORM. It suits larger projects requiring robust security and scalability. Ultimately, the choice hinges on your project's scale, complexity, and your team's familiarity with the frameworks.
Graspan: A Big Data System for Big Code AnalysisAftab Hussain
We built a disk-based parallel graph system, Graspan, that uses a novel edge-pair centric computation model to compute dynamic transitive closures on very large program graphs.
We implement context-sensitive pointer/alias and dataflow analyses on Graspan. An evaluation of these analyses on large codebases such as Linux shows that their Graspan implementations scale to millions of lines of code and are much simpler than their original implementations.
These analyses were used to augment the existing checkers; these augmented checkers found 132 new NULL pointer bugs and 1308 unnecessary NULL tests in Linux 4.4.0-rc5, PostgreSQL 8.3.9, and Apache httpd 2.2.18.
- Accepted in ASPLOS ‘17, Xi’an, China.
- Featured in the tutorial, Systemized Program Analyses: A Big Data Perspective on Static Analysis Scalability, ASPLOS ‘17.
- Invited for presentation at SoCal PLS ‘16.
- Invited for poster presentation at PLDI SRC ‘16.
Neo4j - Product Vision and Knowledge Graphs - GraphSummit ParisNeo4j
Dr. Jesús Barrasa, Head of Solutions Architecture for EMEA, Neo4j
Découvrez les dernières innovations de Neo4j, et notamment les dernières intégrations cloud et les améliorations produits qui font de Neo4j un choix essentiel pour les développeurs qui créent des applications avec des données interconnectées et de l’IA générative.
SOCRadar's Aviation Industry Q1 Incident Report is out now!
The aviation industry has always been a prime target for cybercriminals due to its critical infrastructure and high stakes. In the first quarter of 2024, the sector faced an alarming surge in cybersecurity threats, revealing its vulnerabilities and the relentless sophistication of cyber attackers.
SOCRadar’s Aviation Industry, Quarterly Incident Report, provides an in-depth analysis of these threats, detected and examined through our extensive monitoring of hacker forums, Telegram channels, and dark web platforms.
Need for Speed: Removing speed bumps from your Symfony projects ⚡️Łukasz Chruściel
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
A Study of Variable-Role-based Feature Enrichment in Neural Models of CodeAftab Hussain
Understanding variable roles in code has been found to be helpful by students
in learning programming -- could variable roles help deep neural models in
performing coding tasks? We do an exploratory study.
- These are slides of the talk given at InteNSE'23: The 1st International Workshop on Interpretability and Robustness in Neural Software Engineering, co-located with the 45th International Conference on Software Engineering, ICSE 2023, Melbourne Australia
AI Pilot Review: The World’s First Virtual Assistant Marketing SuiteGoogle
AI Pilot Review: The World’s First Virtual Assistant Marketing Suite
👉👉 Click Here To Get More Info 👇👇
https://sumonreview.com/ai-pilot-review/
AI Pilot Review: Key Features
✅Deploy AI expert bots in Any Niche With Just A Click
✅With one keyword, generate complete funnels, websites, landing pages, and more.
✅More than 85 AI features are included in the AI pilot.
✅No setup or configuration; use your voice (like Siri) to do whatever you want.
✅You Can Use AI Pilot To Create your version of AI Pilot And Charge People For It…
✅ZERO Manual Work With AI Pilot. Never write, Design, Or Code Again.
✅ZERO Limits On Features Or Usages
✅Use Our AI-powered Traffic To Get Hundreds Of Customers
✅No Complicated Setup: Get Up And Running In 2 Minutes
✅99.99% Up-Time Guaranteed
✅30 Days Money-Back Guarantee
✅ZERO Upfront Cost
See My Other Reviews Article:
(1) TubeTrivia AI Review: https://sumonreview.com/tubetrivia-ai-review
(2) SocioWave Review: https://sumonreview.com/sociowave-review
(3) AI Partner & Profit Review: https://sumonreview.com/ai-partner-profit-review
(4) AI Ebook Suite Review: https://sumonreview.com/ai-ebook-suite-review
Enterprise Resource Planning System includes various modules that reduce any business's workload. Additionally, it organizes the workflows, which drives towards enhancing productivity. Here are a detailed explanation of the ERP modules. Going through the points will help you understand how the software is changing the work dynamics.
To know more details here: https://blogs.nyggs.com/nyggs/enterprise-resource-planning-erp-system-modules/
GraphSummit Paris - The art of the possible with Graph TechnologyNeo4j
Sudhir Hasbe, Chief Product Officer, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Utilocate offers a comprehensive solution for locate ticket management by automating and streamlining the entire process. By integrating with Geospatial Information Systems (GIS), it provides accurate mapping and visualization of utility locations, enhancing decision-making and reducing the risk of errors. The system's advanced data analytics tools help identify trends, predict potential issues, and optimize resource allocation, making the locate ticket management process smarter and more efficient. Additionally, automated ticket management ensures consistency and reduces human error, while real-time notifications keep all relevant personnel informed and ready to respond promptly.
The system's ability to streamline workflows and automate ticket routing significantly reduces the time taken to process each ticket, making the process faster and more efficient. Mobile access allows field technicians to update ticket information on the go, ensuring that the latest information is always available and accelerating the locate process. Overall, Utilocate not only enhances the efficiency and accuracy of locate ticket management but also improves safety by minimizing the risk of utility damage through precise and timely locates.
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
Zoom is a comprehensive platform designed to connect individuals and teams efficiently. With its user-friendly interface and powerful features, Zoom has become a go-to solution for virtual communication and collaboration. It offers a range of tools, including virtual meetings, team chat, VoIP phone systems, online whiteboards, and AI companions, to streamline workflows and enhance productivity.
Mobile app Development Services | Drona InfotechDrona Infotech
Drona Infotech is one of the Best Mobile App Development Company In Noida Maintenance and ongoing support. mobile app development Services can help you maintain and support your app after it has been launched. This includes fixing bugs, adding new features, and keeping your app up-to-date with the latest
Visit Us For :
Neo4j - Product Vision and Knowledge Graphs - GraphSummit ParisNeo4j
Dr. Jesús Barrasa, Head of Solutions Architecture for EMEA, Neo4j
Découvrez les dernières innovations de Neo4j, et notamment les dernières intégrations cloud et les améliorations produits qui font de Neo4j un choix essentiel pour les développeurs qui créent des applications avec des données interconnectées et de l’IA générative.
2. TABLE OF
CONTENTS
Introduction......................................................................... 1
Why Generate?..................................................................... 2
The Challenges ..................................................................... 2
The Type Landscape .............................................................. 5
Simple Type.................................................................... 6
W3c Primitives ................................................................ 6
Restrictions..................................................................... 7
Union............................................................................. 8
Choice ........................................................................... 8
List................................................................................ 9
Remarks .............................................................................10
3. INTRODUCTION
W3C schemas can be troublesome.
In domains like travel (Open Travel, IATA NDC), hospitality (HTNG), finance
(ISO20022, SEPA), government (NIEM) and health (Health Level 7), schemas
governing the business messaging, can be both extensive as well as complex. The
example providers mentioned here are by no means a complete list.
Within these domains, and associated with the development of these schema sets,
there is often a business development theme, for example, IATA NDC. However, at
the technical heart of these global standards is the need to deal with the schema
sets, defined as they are, by international working groups.
For a project team tasked with interpreting the schema sets and producing message
handling code, the challenge is to perform this task in such a way that the result
preserves the meaning expressed in the meta-data, maximising fidelity. The idioms
available in the W3C Schema standard are used to the full across the set of domains
noted above, and this elegance and expressiveness can be challenging to translate
into high fidelity code in, say, C# or Java, for example.
Some years ago, the author was on a project, within a global IT provider, which had
the aim of providing an online booking and shopping service for an American airline.
The messages to be used were those defined by Open Travel. At the time this
combined ticketing and shopping approach was novel, pre-dating the arrival of the
NDC initiative of IATA. One of the central arguments of global schema providers is
that usage of their message definitions ensures maximum interoperability between
communicating partners, they all speak the same “language”. However, in this
project because of the complexity of the schemas, which caused real challenges to
interpreting them in a high-level programming language like Java, it was decided to
work with a subset of the definitions, immediately nullifying the interoperability of
the messaging solution.
Once development was underway, it became necessary to prepare for testing a
product increment. For this, the test team researched the appropriate tooling to
allow a range of test messages to be made available for real case coverage. It
turned out that, even in this global IT shop, no such tooling existed, and the
development of the test message structures became a case of handwork.
This approach was completely unsatisfactory in the context of an agile project
process.
4. 2
WHY GENERATE?
Given that schemas represent a data definition, then we might seek to use this as
the source for a transformation process to corresponding (strong) types that could
be used in general development. However, as hinted in the previous section with
the story of the global IT project, there are quite some challenges to be overcome if
we want to take a W3C schema, any such schema, and generate strong types that
match the definition and can thus be used for application development as well as
being able to serialize and de-serialize appropriate messages (sending/receiving) as
specified in the Schema set.
If we could have such a generator, two very powerful benefits would emerge:
1) Retain interoperability since all partners using the generated strong
types would speak the same “language”
2) Embracing changes in the schema definitions would become
straightforward. Of course, appropriate changes in the general
business application would still need to be engineered, but the objects
reflecting the Schema definitions would be easily produced
It is the description of the basis of such a generator which is the subject of this
sequence of articles.
THE CHALLENGES
So, what are the challenges that must be overcome on our way to high-fidelity
generated types?
Firstly, the structural definition of W3C schemas is complex. The idioms that can be
employed by a schema writer are challenging to interpret in a target programming
space. For example, Union and Choice schema elements present challenges to
expression in such languages as C# or Java. In addition, local elements in a Schema
definition which have so-called, complex content, present some challenges to the
generator developer. We also need to embrace the fundamental types of W3C, the
primitive types, e.g., DateTime, and these too require us to devise appropriate
programmatic solutions.
5. 3
In addition, sometimes schema authors interpret a “standard” programmatic entity
in ways that aren’t helpful to those who want to generate code. For example, in a
certain schema one can find an enumeration with the inner element of:
…
<xsd:enumeration value="DOCUMENTS/DATA/PHOTO">
<xsd:annotation>
<xsd:documentation>Not have in my possession any written materials, documents, computer data,
photographs which give evidence of gang involvement or activity such as: (1) membership or enemy lists, (2) articles
which contain or have upon them gang-associated graffiti, drawings or lettering, (3) photographs or newspaper
clippings of gang members, gang crimes or activities including obituaries, (4) photographs of myself in gang
clothing, demonstrating hand signs or holding weapons.
</xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
...
or a restriction on a value expressed as an enumeration, such as:
<xsd:restriction base="xsd:token">
<xsd:enumeration value="3-HIGH RISK"/>
<xsd:enumeration value="COMPACT OUT"/>
<xsd:enumeration value="FUGITIVE"/>
<xsd:enumeration value="2-MODERATE RISK"/>
<xsd:enumeration value="4-EXTREME RISK"/>
<xsd:enumeration value="ISP II"/>
<xsd:enumeration value="1-LOW RISK"/>
<xsd:enumeration value="RESID/IN-STATE CUSTD"/>
<xsd:enumeration value="ISP I"/>
</xsd:restriction>
In both cases, our mythical generator needs to deal, in this case, with enumeration
values with a form that doesn’t match what the target programming space will
accept, C# or Java, for example. In the case where we want to generate from these
definitions, we would first need to have a general algorithm for mapping such value
to acceptable forms. In addition, we would need to persist the original value since
this will be required when serialising/deserializing a message that contains such a
feature.
In this second example, we also see how primitive W3C types can be used to
constrain the scope of a value, in this case, “Token”.
Open Travel
In this article, we will focus on the Open Travel (OTA) schema set as specified in the
first version for the year 2021 (V2021A). Open Travel generally releases two
versions per year, “A” and “B”, which reflect adaptions as requested by the business
community. These adaptions would need to be carefully reviewed by software
development projects to assess their impact on specific products.
6. 4
In earlier years OTA supplied the schema set organised into separate groups e.g.
(air, hotel, loyalty, rail, veh, profile, purchase, reviews, general), to reflect the
different business domains to which the contained schemas applied - Air
Transportation, Hospitality, Rail Transportation, Car Hire, Customer Profile,
Customer Purchasing, Customer Reviews and general definitions). These groups we
will refer to as Silos. However, in 2021, OTA supplied their schemas as one set, no
Silos as far as the basic definition is concerned.
Checking Type Completeness
In order to use a given type produced by our generator, we need some way to
establish the dependent types so that they too can be generated. These types will
be, in general, specified in other schemas within, in our example case, OTA (for
example, the so-called SimpleTypes) as well as types specified by the W3C
organisation (what we will refer to as XSD primitives, as we touched on above).
How can we, in general, establish this Type landscape completeness? The options
are:
Use a generated type in a programming project, build it and react to the
unsatisfied references
Scan the schema from which our specific types are to be generated and find
all dependency references (for example, in such idioms as “include”, “import”,
“xs:…” and “base=…”)
If we look at the OTA air travel request definition (request message definition),
specified in OTA_AirBookRQ.xsd, then applying the second approach above, gives the
following result:
Idiom Referenced Schema/Type Comment
include OTA_AirCommonTypes.xsd This is the schema that needs to be
scanned for needed types. This schema
will probably include/import others (see
below)
Import - None
type= POS_Type
AirItineryType
OTA_CodeType
xs:boolean
The type prefixed by “xs:” are W3C
Primitives, otherwise the type needs to
be found in a dependent schema.
7. 5
TravelerInfoType
FulfillmentType
DateOrDateTimeType
StringLength1to64
UniqueID_Type
EMD_Type
DonationType
AirOfferChoiceType
TransactionActionType
base= BookingPriceInfoType
TicketingInfoType
BookingPriceInfoType
These types form the “base types” for
other types, these types need to be
found in a dependent schema.
With the “include” case we will need to ensure that all dependencies are tracked. In
the case of the one noted above, OTA_AirCommonTypes.xsd, we see the following
dependency structure:
Schema Includes Includes
OTA_AirCommonTypes.xsd OTA_CommonTypes.xsd OTA_SimpleTypes.xsd (final)
OTA_Lists.xsd (final)
OTA_AirPreferences.xsd OTA_AirCommonTypes.xsd (*)
OTA_CommonPrefs.xsd
OTA_CommonPrefs.xsd OTA_CommonTypes.xsd (*)
Where the entries marked (*) represent circular references. So, to have a “type-
complete” solution for our single example type, OTA_AirBookRQ.xsd, we need to
locate and generate all the dependent types. In this context, “type complete
solution” means a collection of definitions, which lead to generated strong types, is
compilable within the target development environment.
THE TYPE LANDSCAPE
The structures expressed in a W3C schema describing a single message can be
complex and dealing with this complexity, and generating a usable strong type, is
challenging. In this section, we outline some of these structures as they reflect in a
Type landscape.
The following sections highlight some of the basic value-type XSD structures that
need to be dealt with by a generator2
8. 6
Simple Type
The euphemistically named Simple Types represent a definition of a single value.
Simple Types can appear in an overall schema at the top level or can be specified
within other schema elements.
The top-level, global, Simple Type has the structure1:
<simpleType
final=(“#all” |
(“list” | “union” | “restriction”))
id=xs:ID
name=xs:NCName
any attributes with non-schema namespace>
(annotation?,(restriction|list|union))
</simpleType>
And this definition is what governs such types, in OTA V2021A, as:
<xs:simpleType name="DateOrMonthDay">
<xs:annotation>
<xs:documentation xml:lang="en">A construct to validate either a date or a month and day
value.</xs:documentation>
</xs:annotation>
<xs:union memberTypes="xs:date xs:gMonthDay"/>
</xs:simpleType>
and:
<xs:simpleType name="ListOfISO3166">
<xs:annotation>
<xs:documentation xml:lang="en">List of country codes in ISO 3166 format.</xs:documentation>
</xs:annotation>
<xs:list itemType="ISO3166"/>
</xs:simpleType>
as well as:
<xs:simpleType name="AlphaNumericStringLength1">
<xs:annotation>
<xs:documentation xml:lang="en">Used for Alpha-Numeric Strings, length 1.</xs:documentation>
</xs:annotation>
<xs:restriction base="xs:string">
<xs:pattern value="[0-9a-zA-Z]{1}"/>
</xs:restriction>
</xs:simpleType>
W3c Primitives
In the Schema types we saw in the previous section, there were a number of places
where references in the form “xs:type-name” occurred, for example, “xs:date”.
These are references to primitive types defined by W3C2
1 XML Schema, Eric van der Vlist, O’Reilly 2002
2 XML Schema String Datatypes (w3schools.com)
9. 7
There are more than forty primitive types, and along with “xs:string” we have such
types as “xs:anyUri”, “xs:double”, “cs:duration”, “xs:token” and
“xs:nonNegativeInteger”.
These definitions need to be available as strong types so that our mythical
generation process can have a closed landscape of types to deal with. These W3C
Primitive Types can be expressed in schema form, for example, in the case of
nonNegativeInteger:
<xs:simpleType name="nonNegativeInteger" id="nonNegativeInteger">
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
</xs:restriction>
<xs:simpleType>
Restrictions
A fundamental feature of XSD type definitions is the specification of so-called
restrictions. We have seen one form in the definition above of
AlphaNumericStringLength1 in the statement block:
…
<xs:restriction base="xs:string">
<xs:pattern value="[0-9a-zA-Z]{1}"/>
</xs:restriction>
…
or the definition of nonNegativeInteger, in the previous section. This specifies that
the underlying form of the value is as specified by the W3C string type, but with the
additional constraint as specified by a regular expression pattern. So, in this case,
valid values would be:
“0”, “h”, “q”
There is a range of restriction types, e.g. “xs:enumeration”, which we saw earlier,
“xs:minLength”, “xs:maxLength”, “xs:fractionDigits” etc, each of which has an
associated “base=” form.
Our generator needs to be able to interpret such definitional structures
appropriately.
10. 8
Union
One of the idioms in W3C schema that does not have a direct form in C# or Java, is
the Union. We encountered it earlier in the definition of DateOrMonthDay. Another
example is:
<xs:simpleType name="DateOrDateTimeType">
<xs:annotation>
<xs:documentation xml:lang="en">A construct to validate either a date or a dateTime value.
</xs:documentation>
</xs:annotation>
<xs:union memberTypes="xs:date xs:dateTime"/>
</xs:simpleType>
This form of definition, in a sense, defines a single object that can hold either of the
two defined values. At any given time only one of the specified values can exist in
the element, either a W3C “date” or a W3C “dateTime”. The C programming
language has a built-in Union type, but C#, Java and Kotlin, for example, do not.
Choice
Another anachronistic idiom of W3C schema is the Choice element (compositor).
The choice allows only one of its children to appear in an instance. An example of
which is exemplified by the definition of the OTA type AppliedRuleType:
<xs:complexType name="AppliedRuleType">
<xs:annotation>
<xs:documentation source="Use" xml:lang="en">
Applied rule information, including category, rule identifier and rule descriptions.</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:choice>
<xs:annotation>
<xs:documentation source="Use" xml:lang="en">
A choice between a default rule indicator OR a rule name and version number.
</xs:documentation>
</xs:annotation>
<xs:element name="DefaultUsedInd" type="xs:boolean">
<xs:annotation>
<xs:documentation source="Use" xml:lang="en">
If true, a system default rule was used.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="RuleInfo">
<xs:annotation>
<xs:documentation source="Use" xml:lang="en">
Information for individual airline applied rules.
</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:attribute name="Name" type="xs:string" use="required">
<xs:annotation>
<xs:documentation source="Use" xml:lang="en">
The name of the applied rule.
</xs:documentation>
</xs:annotation>
11. 9
</xs:attribute>
<xs:attribute name="Version" type="xs:integer" use="optional">
<xs:annotation>
<xs:documentation source="Use" xml:lang="en">
The version of the rule.</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
</xs:element>
</xs:choice>
…
</xs:sequence>
. . .
</xs:complexType>
This is quite a complex definition, even with parts redacted, but at its core, there is
a structure reflecting a choice between two schema elements, DefaultUserInd and
RuleInfo.
List
As the name suggests, the List element is a “value” that is a sequence of strings,
e.g. “First Second Third”. It can also be a list of items of the same type, as specified
in ListOfISO3166:
<xs:simpleType name="ListOfISO3166">
<xs:annotation>
<xs:documentation xml:lang="en">List of country codes in ISO 3166 format.</xs:documentation>
</xs:annotation>
<xs:list itemType="ISO3166"/>
</xs:simpleType>
In this case the list is a white-space separated set of ISO3166 country codes, e.g.
“EN DE IT”.
For modern programming languages handling this sort of “value” would present no
problem. However, the generated class will need to have helper methods to parse
the list.
12. 10
REMARKS
In this article, we have presented some of the challenges related to transforming
W3C Schema definitions into strong types, in target languages like C#, Java and
Kotlin.
In subsequent articles, we will look at how these challenges can be met on our way
to describe a concrete generation pattern.