Published February 27, 2026 | Version v1
Preprint Open

A New Paradigm for Software Design: Autonomous Objects and Integrated Thread Control

Authors/Creators

Description

Modern object-oriented programming faces a critical challenge of excessive architectural complexity and high cognitive load on developers, which frequently leads to design errors in concurrent systems. This research presents a reimagined programming concept, Autonomous Objects, aimed at a radical simplification of software development. By rejecting traditional inheritance in favor of an Active Encapsulation model, this paradigm integrates initialization logic directly into the object body. This approach harmonizes data and processes, creating a more intuitive and secure environment for high-performance concurrent programming.

Key Technical Contributions:

  • Autonomous Threads: Independent execution units that operate with isolated memory copies, effectively eliminating the need for manual locking primitives like mutexes or critical sections.

  • Timer-Driven Execution: A simplified execution logic that replaces manual thread lifecycle management with predictable, automated timer-driven triggers.

  • Semantic Prefix Scoping: A streamlined two-tier variable scoping model using the $ prefix to explicitly clarify variable visibility and reduce unintended side effects.

Note: This is a preprint of a research article currently undergoing peer review.

Files

2026_Zhyrytovskyi_Autonomous_Objects_Preprint.pdf

Files (213.7 kB)

Name Size Download all
md5:a09ff611479b0af6c6b915d7a5360bec
213.7 kB Preview Download

Additional details

Related works

Is supplemented by
Journal article: 10.20535/2786-8729.7.2025.341609 (DOI)

Dates

Issued
2025-02-27

References

  • Wirth N. From programming language design to software construction. Commun ACM. 1988;31(2):116-23.
  • Schildt H. C++: the complete reference. 5th ed. New York: McGraw-Hill Education; 2012.
  • Margulieux LE, Catrambone R, Guzdial M. Cognitive load in introductory programming: a systematic review. Comput Sci Educ. 2022;32(2):171-200.
  • Sweller J, Ayres P, Kalyuga S. Cognitive load theory. New York: Springer; 2011. https://doi.org/10.1007/978-1-4419-8126-4
  • Baletska Z. Reducing cognitive load: the missing key to faster development cycles. Agile Analytics [Internet]. 2025 Jun 6 [cited 2026 Feb 26]. Available from: https://www.agileanalytics.cloud/blog/reducing-cognitive-load-the-missing-key-to-faster-development-cycles
  • Stroustrup B. The design and evolution of C++. Reading (MA): Addison-Wesley; 1994.
  • Kay A. The early history of Smalltalk. ACM SIGPLAN Notices. 1993;28(3):69-95. https://doi.org/10.1145/155360.155364
  • Dijkstra EW. Hierarchical ordering of sequential processes. Acta Inform. 1971;1(2):115-38. https://doi.org/10.1007/BF00289519
  • Lee EA. The problem with threads. Computer. 2006;39(5):33-42. https://doi.org/10.1109/MC.2006.180
  • Agha G. Actors: a model of concurrent computation in distributed systems. Cambridge (MA): MIT Press; 1986.
  • Gamma E, Helm R, Johnson R, Vlissides J. Design patterns: elements of reusable object-oriented software. Reading (MA): Addison-Wesley; 1994.
  • Castagna G, Laurent V, Kim J, et al. Polymorphic records for dynamic languages [Preprint]. arXiv:2404.00338. 2024 [cited 2026 Feb 26]. Available from: https://doi.org/10.48550/arXiv.2404.00338
  • Gosling J, Joy B, Steele G, Bracha G, Buckley S. The Java language specification: Java SE 8 edition. Reading (MA): Addison-Wesley Professional; 2014 [cited 2026 Feb 26]. Available from: https://docs.oracle.com/javase/specs/jls/se8/jls8.pdf
  • Abelson H, Sussman GJ. Structure and interpretation of computer programs. 2nd ed. Cambridge (MA): MIT Press; 1996 [cited 2026 Feb 26]. Available from: https://mitpress.mit.edu/9780262510875/
  • Ousterhout J. A philosophy of software design. 2nd ed. Palo Alto: Yaknyam Press; 2018.
  • Zhang Y, et al. The evolution of timer-driven architectures in modern languages. IEEE Softw. 2025;42(1):12-9.
  • Lattner C. Swift concurrency manifesto [Internet]. Swift Open Source Project; 2021 [cited 2026 Feb 26]. Available from: https://gist.github.com/lattner/31ed37682ef1576b16bca1432ea9f782
  • Hoare CAR. Monitors: an operating system structuring concept. Commun ACM. 1974;17(10):549-57. https://doi.org/10.1145/355620.361161
  • Arpaci-Dusseau RH, Arpaci-Dusseau AC. Operating systems: three easy pieces. v1.10. Arpaci-Dusseau Books; 2023 [cited 2026 Feb 26]. Available from: https://ostep.org/
  • Microsoft Research. Dynamic region ownership for concurrency safety: retrofitting Python with Pyrona. Microsoft Research Reports. 2025 Apr. https://doi.org/10.1145/3729313
  • Cantrill BM, Bonwick JS. Real-world concurrency. Commun ACM. 2008;51(11):34-9. https://doi.org/10.1145/1400214.1400227
  • Hickey R. Simple made easy. Presented at: Strange Loop Conference; 2012; St. Louis, MO. https://www.infoq.com/presentations/Simple-Made-Easy/
  • Tselentis G, et al. Autonomous objects in distributed systems: a new paradigm. J Syst Softw. 2024;201:111683.
  • Fisher M, Mascardi V, Rozier KY, Yorke-Smith N. Toward trustworthy programming for autonomous concurrent systems. AI Soc. 2023;38(2):491-507.