Formalizing Oracle Fusion Application Using Z Notation for EAI

This report addresses the formalization of Oracle Fusion, an enterprise application integration (EAI) solution, using Z notation. The study highlights the importance of software applications in the current digital environment and the role of EAI in ensuring efficient data flow. The report identifies that Oracle Fusion's database system is primarily developed using SQL, which lacks formalization. To address this, the author presents a formal specification for SQL using the Z notation method. The methodology involves defining basic types, sets, and schemas, including class, task, port, and slot schemas, to represent the static and dynamic aspects of the application. The evaluation section discusses the constraints introduced in the solution schema, ensuring the integrity of links between applications and ports. The conclusion emphasizes the significance of formalization in software engineering and suggests future research directions, such as investigating potential security risks associated with Oracle Fusion.

ORACLE FUSION FORMALIZATION USING Z NOTATION
Student
Tutor
Institutional Affiliation
Abstract
The use of software applications has become an obligation for many organizations in the
current digital environment. As such, many companies have implemented the applications and
they use them in running their day to day business activities. Along with this, enterprise
application integration is also adopted in order to ensure efficient flow of information from one
department to another. With that said, this document has proposed a novel enterprise application
integration solution, oracle fusion. Oracle fusion is a software that enables enterprises application
integration. Besides being such a useful solution to enterprise, the application’s database system
is majorly developed by SQL language which is not formalized. As such, this document has
presented a formal specification for the language using z anonymity method.
Key words: enterprise application integration, z notation, SQL, oracle fusion

Oracle Fusion Formalization Using Z Notation
Introduction
In the current digital world, software applications has become an obligation for almost
every business organization. Business in the present day is different from business in the 20th
century and before. There is advancement in technology in the current world and many of the
small scale and large scale business are benefiting from the technology [1]. With the technology
playing a critical role, many business in the current world are moving at a considerable pace.
Organization customers’ data can get ease of control from any place at any time. This is
facilitated by enterprise software integration. The enterprise software integration refer to a
mechanism that aid in efficient flow of data from one application to another application. It also
allow sharing of information.
Sharing of information is a very critical aspect in every enterprise. Business organizations
depends on the application ecosystem that mostly involve software that have already been
developed to run their daily business operations. There are various software which serve this
purpose, these applications have been adopted by various organizations for system integration.
However, some of these applications have been reported to be less effective in integrating
organization applications this is due to the reason that a few organizations that implement them
have been reporting issues to the application vendors [2].
Application integration is very essential in technology based business process. The
primary goal of the enterprises application integration is to ensure that the application data is
synchronized. As software, there are chances that the implemented enterprise application
integration solutions fail [1]. In order to avoid such integration application failures, it is essential

to choose a robust software for enterprise application integration. Tibco, Biztalk and many other
enterprise application integration software facilitate enterprise application integration. Be that as
it may, to the best of my knowledge, Oracle fusion is one software integration application that
has proven to be more efficient among other applications.
Statement of problem
The oracle’s main built in language is PL/SQL. This language enable its users to program
against it to create and manage the application database as well as the data that is stored in it.
However, with regards to rule based language, rules can be written by software engineers in
order to correct execution and express the expected behavior of Oracle fusion application when it
is implemented [3]. Additionally, developing an application that precisely describes an enterprise
application integrations solution depends on formality. Besides being available for enterprises,
the Oracle fusion application has not yet gotten formalized. Honestly, it is not possible to reason
with enterprise application integrations solutions that is not formalized. In this rationale, the
primary objective of this document is to formalize oracle fusion by providing verification of its
languages including SQL using z notation formal method.
Related works
Software formalization has been a topic of concern since the implementation of the
principles of software engineering. Formalization means a general rule for all software engineers
that use mathematical tools as a basis for software development. There has been growth in the
interest of formality since it got formulated. According to [5], any programming language
regardless of how low it is must be complete with all syntax rule as well as a clear description for
its meaning. Sometimes, this is normally ignored by some computer language designers [6]. The

authors further states that developing semantic language which is formal alongside execution and
analysis tool for the language is very essential.
Formalizing computer languages has become a prominent domain. There are a number of
literary works which offers formal specifications used for forming computer languages as
proposed in this document. In [7], Chanda and his team formalize UML, the authors provide a
formal semantic, and they use compositional logic of action. The formal specification has a
considerable contribution in software engineering. One of the major contribution of the approach
is that it can get manipulated by various tools for a wide ranging reasons so as to ensure
adequacy.
Methodology
This section presents the formalization method. The z notation formalization approach is
utilized for the formal definition of the criteria. The main construct here include z schema which
is further divided into two main parts including predicate and declaration part. The abstract
syntax of SQL language will get formalized in this section.
The building blocks will be defined by names in the enterprise application integration. As
a result, it is essential to identify names as a basic types of the specification. The following
expression shows the basic types of all codes.
[name, script]
The type to be set is defined in the following expression:
Type=application/process/task

For all building blocks to have unique identification, a constraint denotation is explicitly written
using the following expression:
Type 1, type 2: type.
The remaining sets are then defined using z schema which is divided into two parts as have been
mentioned in the previous section of the document.
Discussion
A state schema in the z notation for formalizing the static aspect of class is known as
class schema. As mentioned earlier, the class schema has two classes which contain predicative
and declared variables. They present the object identifiers and attributes as a class. Task schema,
on the other hand provides a description of building block tasks which declares four variables
including name, input and output.
Here, the declarative parts of the task schemas are defined through the use of variables
without considering the relationship that exist between other z schemas. The expression one
above describe the set names and scripts. The sets entryports and exitports were identified using
the name and type of the task. There intersection forms empty set which can be seen from the
port schema. In the PL/SQL used in development of the oracle fusion, two tasks can be
connected with a port. Thus slot schema in the specification describes building bloc slots in
which 3 variables are declared [8]. A slot where two tasks are connected is gets modelled as a set
of binary relations between the tasks and the set tasks. The connections between a port and a
task, on the other hand can be modelled as a set of binary relations between the port and the set
tasks.

The oracle fusion solution process can be identified by names and is composed of slots,
ports including both entryport and exitport as well as tasks. As mentioned previously, a process
can get classified as a schema where its subset declaration and main predicate are well defined
[10]. This part is predicative since the slot definition is related to the two different tasks. Other
sets which are composed of integration solution are declared after which the definition of some
predicates and declaration of sub sets process declaration are also made.
Consequently, the application and link schemas are described at this stage. The
application includes a unique name used for identification purposes along with other two sets of
ports including entry port and exit port. Likewise, a link also has a name that uniquely identifies
it. This include the application and integration links [10]. Each of the names has two forms of
relationships. The first name has a relationship between the entryport and exitport while the last
name has a relationship between port and application. The general formalization of the oracle
fusion application can be presented with the declaration of the two schema.
Evaluation
This section presents an evaluation of the formalization process. So far, the solution
schema having two constraints has been defined. According to the findings, the first constrain
introduces the relation link including entryport and exitports of processes where the entryport
must be different from the exitport [11]. The second constraint, on the other hand, presents the
application link as the relationship between the port and the application. This ensures that two
different applications does not get connected to same ports [12]. As a result, it can be concluded
that for link one and link two for the set links and the first and second applications from the set
applications, as well as port one from the ports where the applicationlink relates application two
and port one is and only if application one is equal to application two i.e.

Link > 1
Process > 1
Application > 1
Conclusion
In summary, the subject of this study involve using z notation formalization. The
document has illustrated the state of art of enterprise application integration application. We have
also recommend an enterprise application integration solution including oracle fusion application
which has been found to be developed using SQL language for effective data management. In the
document, we have formalize the SQL language used for designing the system through z
notation method. This document act as a stepping stone for future research. As search, it
recommends one area stated as follows for further research study. The document recommends
future researchers to focus on the possible security risks that oracle fusion application can pose
to an enterprise.

References
[1] He W, Da Xu L. Integration of distributed enterprise applications: A survey. IEEE
Transactions on industrial informatics. 2014 Feb;10(1):35-42.
[2] Oracle help center. (2019). “Known issues for oracle Integration.” Retrieved on 8th may 2019
from: <https://docs.oracle.com/en/cloud/paas/integration-cloud/known-issues/common-
issues.html#GUID-F2A89E0B-2F61-48D7-9615-DD95A6B47E5B>
[3] Gökçe KU, Gökçe HU, Katranuschkov P. IFC-based product catalog formalization for
software interoperability in the construction management domain. Journal of computing in civil
engineering. 2012 Jan 12;27(1):36-50.
[4] Yao QZ, Wang J. Software formalization requirements analysis and verification based on
UML. Computer Engineering. 2010;36(13):30-3.
[5] Klein MJ, Sawicki S, Roos-Frantz F, Frantz RZ. On the Formalisation of an Application
Integration Language Using Z Notation. InICEIS (1) 2014 Apr 27 (pp. 314-319).
[6] Czopik J, Košinár MA, Štolfa J, Štolfa S. Formalization of software process using intuitive
mapping of UML activity diagram to CPN. InProceedings of the Fifth International Conference

on Innovations in Bio-Inspired Computing and Applications IBICA 2014 2014 (pp. 365-374).
Springer, Cham.
[7] Chanda J, Kanjilal A, Sengupta S, Bhattacharya S. Traceability of requirements and
consistency verification of UML use case, activity and Class diagram: A Formal approach.
In2009 Proceeding of International Conference on Methods and Models in Computer Science
(ICM2CS) 2009 Dec 14 (pp. 1-4). IEEE.
[8] Pai S, Sharma Y, Kumar S, Pai RM, Singh S. Formal verification of OAuth 2.0 using Alloy
framework. In2011 International Conference on Communication Systems and Network
Technologies 2011 Jun 3 (pp. 655-659). IEEE.
[9] Banerjee P, Sarkar A. Z–Specification of Component Based Software. International Journal
of Software Engineering and Its Applications, Science & Engineering Research Support Society
(SERSC), Australia. 2014 Jan;8(1):1-20.
[10] Ibrahim R. Formalization of the data flow diagram rules for consistency check. arXiv
preprint arXiv:1011.0278. 2010 Nov 1.
[11] Hierons RM, Bogdanov K, Bowen JP, Cleaveland R, Derrick J, Dick J, Gheorghe M,
Harman M, Kapoor K, Krause P, Lüttgen G. Using formal specifications to support testing.
ACM Computing Surveys (CSUR). 2009 Feb 1;41(2):9.
[12] Jackson E, Sztipanovits J. Formalizing the structural semantics of domain-specific modeling
languages. Software & Systems Modeling. 2009 Sep 1;8(4):451-78.