arXiv subjects

Sabah Al-Fedaghi

Publications and source records attributed to Sabah Al-Fedaghi.

At least 55 records · Page 3Linked to original sources

arXiv2021

Conceptual Model with Built-in Process Mining

Process mining involves discovering, monitoring, and improving real processes by extracting knowledge from event logs in information systems. Process mining has become an important topic in recent years, as evidenced by a growing number of case studies and commercial tools. Current studies in this area assume that event records are created separately from a conceptual model (CM). Techniques are then used to discover missing processes and conformance with the CM, as well as for checks and enhancements. By contrast, in this paper we focus on modeling events as part of a tight multilevel CM that includes a static description, dynamics, events-log scheme, and monitoring and control system. If there is an out-of-model event log, it is treated as a requirement needed to build or enrich the CM. The motivation for such a unified system is our thesis that process mining is an essential component of a CM with built-in mining capabilities to perform self-process mining and attain completeness. Accordingly, our proposed conceptual model facilitates collecting data generated about itself. The resultant framework emphasizes an integrated representation of systems to include process-mining functionalities. Case studies that start with event logs are recast to evolve around a model-first approach that is not limited to the initial event log. The result presents a framework that achieves the aims of process mining in a more comprehensive way

cs.SE↗

arXiv2021

Diagrammatic Formalism for Complex Systems: More than One Way to Eventize a Railcar System

This paper is in the intersection of software engineering and system engineering, two intimately intertwined disciplines. A dominating theme in this paper is the integral conceptualization of systems at large, as well as an underlying concern with software systems. In the software development life cycle, challenges still exist in translating requirements into a design artifact and then into an implementation (e.g., coding), then validating the results. From our perspective, software engineering requires an integrating paradigm toward a unified modeling orientation. Many methodologies, languages, and tools exist for facilitating system development processes. This paper is a venture into project development. To focus the materials, we concentrate on Harel s novel (and classic) development environment, which integrates a scenario-based engineering object orientation and statecharts through developing a railcar system. The railcar system is used as a detailed sample of translating requirements into a design artifact and then into an implementation, then validating the result. The project is re-cased as a single integrated modeling endeavor to be contrasted with the scenario and statecharts development. The result of this scheme is an enriched understanding through experimenting with and contrasting various development methods of software projects.

cs.SE↗

arXiv2021

Conceptual Modeling for Computer Organization and Architecture

Understanding computer system hardware, including how computers operate, is essential for undergraduate students in computer engineering and science. Literature shows students learning computer organization and assembly language often find fundamental concepts difficult to comprehend within the topic materials. Tools have been introduced to improve students comprehension of the interaction between computer architecture, assembly language, and the operating system. One such tool is the Little Man Computer (LMC) model that operates in a way similar to a computer but that is easier to understand. Even though LMC does not have modern CPUs with multiple cores nor executes multiple instructions, it nevertheless shows the basic principles of the von Neumann architecture. LMC aims to introduce students to such concepts as code and instruction sets. In this paper, LMC is used for an additional purpose: a tool with which to experiment using a new modeling language (i.e., a thinging machine; TM) in the area of computer organization and architecture without involving complexity in the subject. That is, the simplicity of LMC facilitates the application of TM without going deep into computer organization/architecture materials. Accordingly, the paper (a) provides a new way for using the LMC model for whatever purpose (e.g., education) and (b) demonstrates that TM can be used to build an abstract level of description in the organization/architect field. The resultant schematics from the TM model of LMC offer an initial case study that supports our thesis that TM is a viable method for hardware/software-independent descriptions in the computer organization and architect field of study.

cs.CY↗

arXiv2021

UML Modeling to TM Modeling and Back

Certainly, the success of the Unified Modeling Language (UML) as the de facto standard for modeling software systems does not imply closing the door on scientific exploration or experimentation with modeling in the field. Continuing studies in this area can produce theoretical results that strengthen UML as the leading modeling language. Recently, a new modeling technique has been proposed called thinging machine (TM) modeling. This paper utilizes TM to further understand UML, with two objectives: (a) Fine issues in UML are studied, including theoretical notions such as events, objects, actions, activities, etc. Specifically, TM can be used to solve problems related to internal cross-diagram integration. (b) TM applies a different method of conceptualization, including building a model on one-category ontology in contrast to the object-oriented paradigm. The long-term objective of this study is to explore the possibility of TM complementing certain aspects in the UML methodology to develop and design software systems. Accordingly, we alternate between UML and TM modeling. A sample UML model is redesigned in TM, and then UML diagrams are extracted from TM. The results clarify many notions in both models. Particularly, the TM behavioral specification seems to be applicable in UML.

cs.SE↗

arXiv2021

Conceptual Temporal Modeling Applied to Databases

We present a different approach to developing a concept of time for specifying temporality in the conceptual modeling of software and database systems. In the database field, various proposals and products address temporal data. The difficulty with most of the current approaches to modeling temporality is that they represent and record time as just another type of data (e.g., values of a bank balance or amounts of money), instead of appreciating that time and its values are unique, in comparison to typical data attributes. Time is an engulfing phenomenon that lifts a system s entire model from staticity to dynamism and beyond. In this paper, we propose a conceptualization of temporality involving the construction of a multilevel modeling method that progresses from static representation to system compositions that form regions of dynamism. Then, a chronology of events is used to define the system s behavior. Lastly, the events are viewed as data sources with which to build a temporal model. A case-study model of a temporal banking-management system database that extends UML and the object-constraint language is re-modeled using thinging machine (TM) modeling. The resultant TM diagrammatic specification delivers a new approach to temporality that can be extended to be a holistic monitoring system for historic data and events.

cs.SE↗

arXiv2021

Advancing Behavior Engineering: Toward Integrated Events Modeling

The term behavior engineering (BE) encompasses a broad integration of behavioral and compositional requirements needed to model large-scale systems. BE forms a connection between systems-engineering processes and software-engineering processes. In software engineering, interpreting requirements can be perceived as specifying behavior, which is viewed in terms of chronology of events in the modeled system. In this paper, we adopt BE in its general and integrating sense to search for a unifying notion of an event as a fundamental behavior-modeling concept. We examine several bodies of research with various definitions of an event and its basic units and structure. We use the thinging machine (TM) model to analyze notions related to events, including Dromey s behavior trees, fluents (change over time), recurrent events, and Davidson s events. The results point to an underlying meaning that can lead to a unifying event concept.

cs.SE↗

arXiv2020

Conceptual Software Engineering Applied to Movie Scripts and Stories

This study introduces another application of software engineering tools, conceptual modeling, which can be applied to other fields of research. One way to strengthen the relationship between software engineering and other fields is to develop a good way to perform conceptual modeling that is capable of addressing the peculiarities of these fields of study. This study concentrates on humanities and social sciences, which are usually considered softer and further away from abstractions and (abstract) machines. Specifically, we focus on conceptual modeling as a software engineering tool (e.g., UML) in the area of stories and movie scripts. Researchers in the humanities and social sciences might not use the same degree of formalization that engineers do, but they still find conceptual modeling useful. Current modeling techniques (e.g., UML) fail in this task because they are geared toward the creation of software systems. Similar Conceptual Modeling Language (e.g., ConML) has been proposed with the humanities and social sciences in mind and, as claimed, can be used to model anything. This study is a venture in this direction, where a software modeling technique, Thinging Machine (TM), is applied to movie scripts and stories. The paper presents a novel approach to developing diagrammatic static/dynamic models of movie scripts and stories. The TM model diagram serves as a neutral and independent representation for narrative discourse and can be used as a communication instrument among participants. The examples presented include examples from Propp s model of fairytales; the railway children and an actual movie script seem to point to the viability of the approach.

cs.AI↗

arXiv2020

Exploration in Algorithm Engineering: Modeling Algorithms

According to some algorithmicists, algorithmics traditionally uses algorithm theory, which stems from mathematics. The growing need for innovative algorithms has caused increasing gaps between theory and practice. Originally, this motivated the development of algorithm engineering, which is viewed as experimental techniques related to software engineering. Currently, algorithm engineering is a methodology for algorithmic research that combines theory with implementation and experimentation in order to produce better algorithms with high practical impact. Still, researchers have questioned whether the notion of algorithms can be defined in a fully generable way and discussed what kinds of entities algorithms actually are. They have also struggled to maintain a view that formulates algorithms mathematically (e.g., Turing machines and finite-state machines [FSMs]) while adapting a more applied view. Answering the question of what algorithms have practical applications in software specifications in particular, this paper proposes a diagrammatical definition of an algorithm based on a new modeling machine called a thinging machine (TM). The machine has five actions (e.g., create, process, release, transfer, and receive) that can form a network of machines. The paper explores the application of the definition in Turing machines and FSMs. The results point to the fact that the proposed definition can serve as a middle-ground representation of algorithms, a definition which is between formal specification and the commonly used informal definition (e.g., set of instructions).

cs.SE↗

arXiv2020

High-Level Description of Robot Architecture

Architectural Description (AD) is the backbone that facilitates the implementation and validation of robotic systems. In general, current high-level ADs reflect great variation and lead to various difficulties, including mixing ADs with implementation issues. They lack the qualities of being systematic and coherent, as well as lacking technical-related forms (e.g., icons of faces, computer screens). Additionally, a variety of languages exist for eliciting requirements, such as object-oriented analysis methods susceptible to inconsistency (e.g., those using multiple diagrams in UML and SysML). In this paper, we orient our research toward a more generic conceptualization of ADs in robotics. We apply a new modeling methodology, namely the Thinging Machine (TM), to describe the architecture in robotic systems. The focus of such an application is on high-level specification, which is one important aspect for realizing the design and implementation in such systems. TM modeling can be utilized in documentation and communication and as the first step in the system s design phase. Accordingly, sample robot architectures are re-expressed in terms of TM, thus developing (1) a static model that captures the robot s atemporal aspects, (2) a dynamic model that identifies states, and (3) a behavioral model that specifies the chronology of events in the system. This result shows a viable approach in robot modeling that determines a robot system s behavior through its static description.

cs.RO↗

arXiv2020

Towards Conceptual Modeling Semantics: Eventizing Tarski's Truth Schema

Modeling languages in software engineering (e.g., UML) evolved from software systems modeling where denotational and operational kinds of semantics are the traditional subjects of research and practice. According to some authors, although a large portion of the static semantics (e.g., UML) seems to have reached a consensus, the dynamic semantics of activities, interactions, and state machines poses a major challenge. Central to semantics is the relationship between a sentence and the (actual) world. Carefully examining semantics-related issues in the modeling languages field to avoid problems that may affect practical applicability is important. One effort in this direction is OMG s release of a 2020 draft specification for Foundational UML (fUML), with the base semantics specifying executions that are executable in the same sense as a program in a traditional programming language. Additionally, efforts within academia have sought to develop an alternative approach to modeling languages using formal semantics (e.g., using Russell s theory of types and Tarski s declarative semantics). This paper aims at a similar exploratory venture of developing semantics, only for a much more modest diagrammatic modeling language, called the thinging machine model. The model promotes a deep understanding of the scrutinized modeling language and leads to considerably fruitful questions. Constructing the thinging machine model seems to facilitate progress in this direction, and the initial results in this paper indicate the viability of the approach.

cs.SE↗

arXiv2020

Underpinning Theories of Software Engineering: Dynamism in Physical Sources of the Shannon Weaver Communication Model

This paper aims to contribute to further understanding of dynamism (the dynamic behavior of system models) in the mathematical and conceptual modeling of systems. This study is conducted in the context of the claim that software engineering lacks underpinning scientific theories, both for the software it produces and the processes by which it does so. The research literature proposes that information theory can provide such a benefit for software engineering. We explore the dynamism expressive power of conceptual modeling as a software engineering tool that can represent physical systems in the Shannon Weaver communication model (SWCM). Specifically, the modeled source in the SWCM is a physical phenomenon (a change that can occur in the world, e.g., tossing a coin) resulting in generating observable events and data of unaddressed information. The resultant model reflects the feasibility of extending the SWCM to be applied in conceptual modeling in software engineering.

cs.SE↗

arXiv2020

Computer Program Decomposition and Dynamic/Behavioral Modeling

Decomposition, statically dividing a program into multiple units, is a common programming technique for realizing parallelism and refining programs. The decomposition of a sequential program into components is tedious, due to the limitations of program analysis and because sequential programs frequently employ inherently sequential algorithms. This paper contributes to this area of study by proposing a diagrammatic methodology to decompose a sequential program. The methodology involves visualizing the program in terms of a conceptual model called the thinging machine (TM) model. The TM diagram-based model establishes three levels of representation (1) a static description; (2) a dynamic representation; and (3) a behavioral model. The decomposition is performed in the last phase of modeling, according to the streams of events. This method is contrasted with formal decomposition specifications and compared with the typical decomposition of a C++ program. The results point to the viability of using TM for decomposing programs.

cs.SE↗

arXiv2020

Changes, States, and Events: The Thread from Staticity to Dynamism in the Conceptual Modeling of Systems

This paper examines the concept of change in conceptual modeling. Change is inherent in the nature of things and has increasingly become a focus of much interest and investigation. Change can be modeled as a transition between two states of a finite state machine (FSM). This change represents an exploratory starting point in this paper. Accordingly, a sample FSM that models a car s transmission system is re-expressed in terms of a new modeling methodology called thinging machine (TM) modeling. Recasting the car-transmission model involves developing (1) an S model that captures the static aspects, (2) a D model that identifies states, and (3) a B model that specifies the behavior. The analysis progresses as follows. - S represents an atemporal diagrammatic description that embeds underlying compositions (static changes) from which the roots of system behavior can be traced. - S is broken down into multiple subsystems that correspond to static states (ordered constitutive components). - Introducing time into static states converts these states into events, and the behavior (B) model is constructed based on the chronology of these events. The analysis shows that FSM states are static (atemporal) changes that introduce temporal events as carriers of behavior. This result enhances the semantics of the concepts of change, states, and events in modeling and shows how to specify a system s behavior through its static description.

cs.SE↗

arXiv2020

Dissipating with Relations: Implication for the Entity-Relationship Model

Difficulties arise when conceptual modeling lacks ontological clarity and rigorous definitions, which is especially the case in the relationship construct. Evidence shows that use of relationships is often problematic when it comes to communicating the form of meaning of an application domain. Research on this topic is important because relationships are central to a number of approaches and commonly used by practitioners. In this paper, we study the notion of relation or relationship in the context of conceptual modeling. Specifically, we focus on the notion of relationship used in the entity-relationship (ER) model. The ER model is scrutinized through a new form of conceptual modeling called the thinging machine (TM) to pursue further understanding of the semantics of the relationship concept. The ER model is composed of three fundamental categories (i.e., entity, relationship and attribute), whereas TM is built from one ontological category called the thing/machine (thimac). Several ER diagrams are re-casted as TM diagrams, creating a categorical collision with interesting implications regarding the status of the conception of relationship in a conceptual model. The re-modeling shows that the relational construct is dissipated into TM flows of things and chronology of events.

cs.SE↗

arXiv2020

Conceptual Modeling of Time for Computational Ontologies

To provide a foundation for conceptual modeling, ontologies have been introduced to specify the entities, the existences of which are acknowledged in the model. Ontologies are essential components as mechanisms to model a portion of reality in software engineering. In this context, a model refers to a description of objects and processes that populate a system. Developing such a description constrains and directs the design, development, and use of the corresponding system, thus avoiding such difficulties as conflicts and lack of a common understanding. In this cross-area research between modeling and ontology, there has been a growing interest in the development and use of domain ontologies (e.g., Resource Description Framework, Ontology Web Language). This paper contributes to the establishment of a broad ontological foundation for conceptual modeling in a specific domain through proposing a workable ontology (abbreviated as TM). A TM is a one-category ontology called a thimac (things/machines) that is used to elaborate the design and analysis of ontological presumptions. The focus of the study is on such notions as change, event, and time. Several current ontological difficulties are reviewed and remodeled in the TM. TM modeling is also contrasted with time representation in SysML. The results demonstrate that a TM is a useful tool for addressing these ontological problems.

cs.AI↗

arXiv2020

Modeling the Semantics of States and State Machines

A system s behavior is typically specified through models such as state diagrams that describe how the system should behave. According to researchers, it is not clear what a state actually represents regarding the system to be modeled. Standards do not provide adequate definitions of or sufficient guidance on the use of states. Studies show these inconsistencies can lead to poor or incomplete specifications, which in turn could result in project delays or increase the cost of the system design. This paper aims to establish a precise definition of the notion of states and state machines, a goal motivated by system modelers (e.g., requirement engineers) need to understand key concepts and vocabulary such as states and state machine, which are major behavioral modeling tools (e.g., in UML). State is the main notion of a state machine in which events drive state changes. This raises questions about the nature of these state-related notations. The semantics of these concepts is based on a new modeling methodology called the thinging machine applied to a number of examples of existing models. The thinging machine semantics is founded on five elementary actions that divide the static model into changes/states upon which events are defined.

cs.SE↗

arXiv2020

How to Document Computer Networks

Documenting networks is an essential tool for troubleshooting network problems. The documentation details a network's structure and context, serves as a reference and makes network management more effective. Complex network diagrams are hard to document and maintain and are not guaranteed to reflect reality. They contain many superficial icons (e.g., wall, screen and tower). Defining a single coherent network architecture and topology, similar to engineering schematics, has received great interest. We propose a fundamental approach for methodically specifying a network architecture using a diagramming method to conceptualize the network s structure. The method is called a thinging (abstract) machine, through which the network world is viewed as a single unifying element called the thing/machine (thimac), providing the ontology for modeling the network. To test its viability, the thinging-machine-based methodology was applied to an existing computer network to produce a single integrated, diagrammatic representation that incorporates communication, software and hardware. The resultant description shows a viable, coherent depiction that can replace the current methods.

cs.NI↗

arXiv2020

Thinging-Oriented Modeling of Unmanned Aerial Vehicles

In recent years, there has been a dramatic increase in both practical and research applications of unmanned aerial vehicles (UAVs). According to the literature, there is a need in this area to develop a more refined model of UAV system architecture, in other words, a conceptual model that defines the system s structure and behavior. The existing models mostly are fractional and do not account for the entire important dynamic attributes. Progress in this area could reduce ambiguity and increase reliability in the design of such systems. This paper aims to advance the modeling of UAV system architecture by adopting a conceptual model called a thinging (abstract) machine in which all of the UAV s software and hardware components are viewed in terms of the flow of things and five generic operations. We apply this model to a real case study of a drone. The results, an integrated conceptual representation of the drone, support the viability of this approach.

cs.SE↗