Thinging Ethics for Software Engineers

Ethical systems are usually described as principles for distinguishing right from wrong and forming beliefs about proper conduct. Ethical topics are complex, with excessively verbose accounts of mental models and intensely ingrained philosophical assumptions. From practical experience, in teaching ethics for software engineering students, an explanation of ethics alone often cannot provide insights of behavior and thought for students. Additionally, it seems that there has been no exploration into the development of a conceptual presentation of ethics that appeals to computer engineers. This is particularly clear in the area of software engineering, which focuses on software and associated tools such as algorithms, diagramming, documentation, modeling and design as applied to various types of data and conceptual artifacts. It seems that software engineers look at ethical materials as a collection of ideas and notions that lack systemization and uniformity. Accordingly, this paper explores a thinging schematization for ethical theories that can serve a role similar to that of modeling languages (e.g., UML). In this approach, thinging means actualization (existence, presence, being) of things and mechanisms that define a boundary around some region of ethically related reality, separating it from everything else. The resultant diagrammatic representation then developed to model the process of making ethical decisions in that region.

💡 Research Summary

**
The paper addresses a persistent problem in software engineering education: ethics is often taught as a collection of abstract principles and philosophical assumptions that do not resonate with engineering students. While professional societies such as ACM and IEEE provide codes of conduct, there is no systematic, diagrammatic representation that aligns with the way software engineers think about systems, models, and processes. To fill this gap, the authors introduce a modeling framework called “Thinging Machines” (TM), which adapts the philosophical notion of “thinging” into a concrete engineering notation similar to UML.

A TM diagram consists of two fundamental concepts: things (entities that exist, are created, processed, transferred, received, or released) and machines (the mechanisms that act on things). The five primitive operations—Create, Process, Receive, Release, Transfer—are visualized as directed flows between boxes, mirroring the classic Input‑Process‑Output (IPO) model but extending it to non‑physical domains such as moral reasoning. The authors first illustrate TM with a familiar engineering example: a water‑reservoir system. Water (a thing) flows from an external source, passes through a valve machine, is measured by a sensor sub‑machine, processed by a controller, and finally released or retained. Events are modeled as sub‑machines that contain temporal and spatial sub‑components, showing how TM can capture dynamic behavior as well as static structure.

Having demonstrated the mechanics of TM, the paper proceeds to map ethical theories onto the same formalism. Ethical systems are treated as collections of “ethical things” (principles, duties, contexts) that are manipulated by “ethical machines” (decision procedures, reasoning steps). The authors apply this approach to two concrete ethical frameworks:

1. Kantian Deontology – The categorical imperative is represented as a thing created at the beginning of the decision process. Actions are processed through a machine that checks universalizability, respects autonomy, and finally releases the moral verdict. The diagram makes explicit the flow from duty definition to action evaluation, allowing students to see where a violation occurs.

2. Islamic Ethics – Here, Sharia law is modeled as a foundational thing, while the “Sharia court” functions as a machine that interprets contextual factors, applies jurisprudential rules, and produces a release (the ethical outcome). This example demonstrates TM’s capacity to incorporate cultural and religious dimensions without altering the underlying notation.

The key contributions of the work are:

• Systematization of Ethics – By translating ethical reasoning into a flow‑based diagram, the authors provide a common visual language that aligns with software engineers’ existing skill set in modeling and diagramming.
• Compatibility with Existing Tools – TM’s syntax resembles UML, enabling educators to adopt it without requiring students to learn an entirely new language.
• Traceability of Moral Decisions – Each step in the ethical reasoning process is captured as a distinct machine operation, making it easier to audit, discuss, and revise decisions.
• Flexibility for Updates – Errors or new normative requirements can be incorporated by editing the diagram rather than rewriting textual explanations, supporting continuous ethical governance.

The paper also acknowledges limitations. TM introduces a new meta‑model, which may impose an initial learning curve. Over‑simplification of complex moral dilemmas is a risk, and the current study only explores Kantian and Islamic ethics, leaving out consequentialist, virtue‑ethical, and contractarian frameworks. Future work is suggested in three areas: development of software tooling to author and simulate TM diagrams, large‑scale empirical studies in classroom settings, and comparative modeling of a broader set of ethical theories.

In conclusion, “Thinging Ethics for Software Engineers” proposes a novel, diagram‑centric approach that reframes ethics as a system‑level concern akin to architectural design. By doing so, it promises to make ethical reasoning more concrete, communicable, and actionable for future software professionals, thereby bridging the gap between moral philosophy and engineering practice.