About Me:

GitHub - YouTube - LinkedIn - Gmail - WhatsApp

Welcome, it’s an honor for me that you’ve reached here! I’m Pavly Gerges. I’m a self-taught OSS Engineer from the medical profession totally delved into with passion towards open-science and open-source Hardware/Software Engineering.

My Education:

I graduated from Faculty of Medicine and Surgery, October 6 University in 2023 with GPA-3.15, and currently taking my medical internship. I am currently holding a Bachelor degree of Medicine and Surgery (M.B.B.Ch.), however, not entitled yet to practice medicine.

Overview of my Computer Engineering education:

Though I’m a medical candidate, I’ve got enough wisdom over these years to find the common scientific bases among Software Engineering and Medicine, which are very huge to list them here in this section. Comprehensively, through this genuine way, I’ve been able to focus on and study both fields. Regarding computer engineering, I’m currently studying Embedded Systems, and Game Engines Development among other pure sciences including, but not limited to, Calculus, Linear Algebra and Discrete Mathematics. I’m seeking more knowledge and wisdom in the field of distributed simulation systems that combine all my studies in one place. All my studies run from books, documentation manuals, technical reports, and journals, and rarely workshop webinar tutorials.

Skills:

• Languages: Java - Kotlin - C/C++ - Groovy - Bash (Shell Scripting).
• Java Platform: Java Reflection API - Java Native Interface (JNI) - JNI Invocation API - Java Command-line tools.
• Gradle: Gradle - Gradle Plugins - Gradle Core Platform Modular Architecture - Gradle Multi-project Builds.
• Crossplatform API Design and development: Software Architectural Design - Concurrent Programming - Object-oriented Design - Design Patterns - Entity-Component-System Design - Procedural Programming (Finite Automata) - Sqlite DB - Data Structures - Algorithms - POSIX - GNU Compiler Collection (GCC) - Android Core SDK - Android NDK - GLSL - OpenGL - PlantUML - Sonatype/Maven Deployment.
• Technical Writing: Documentation - Tutorials.
• Building and Automation: CMake - BASH - JUnit - Group Testing (jme3-testable pilot API) - Git/GitHub VCS - GitHub Actions (CI/CD) - Windows-Subsystem For Linux (WSL).
• Embedded Systems: C/C++ Programming - Java Native Interface (JNI) - Microcontroller Programming - GNU/Linux Libc - jMonkeyEngine Framework - Hardware/Software Co-design - Distributed Simulations.
• Pure Sciences: Scientific Modelling - Scientific Philosophy - Discrete Mathematics - Calculus - Linear Algebra - Applied Theory - Medical and Clinical Sciences - System Design.
• Debugging and Profiling: Java Utility Loggers (JUL) - jconsole - Android Profiler - Java Flight Recorder (JFR) - GNU Debugger (GDB).

Experience:

Essentially, all my contributions are entitled to open-source projects through different routes, either through non-profit open-source organizations (e.g., jMonkeyEngine - Pi4j) or through self-initiated projects on Electrostat-Lab organization, see the projects section.

jMonkeyEngine Contributions:

Contributor | (2020 - Present)

I’ve been contributing to jMonkeyEngine, an open-source code-first approach complete 3D game engine suite written primarily in Java with GLSL Java bindings based on the OpenGL pipelines and modular API design, for about 4 years, and still contributing.

What does the current jMonkeyEngine team do?

The current team activities are essentially:

• Maintaining the current codebase for cross-platform game applications development.
• Community Management.
• Features support and Engine Releases.
• Plugins, API design, and building sub-projects.

What were my activities during this period?

• JmeSurfaceView: During my first year, I proposed and introduced JmeSurfaceView, a GL Surface View handler component for embedding jMonkeyEngine Game Contexts into Android Layout Designs, and it’s proven comptency over time in this pilot project Game-HCI, which houses reusable I/O Game GUI components leveraging the power of the MVC architectural patterns together with userinput lifecycle linkage through command-state and strategy patterns (i.e., controller interfaces).

• ContrastAdjustmentFilter: I worked on another shiny feature, a ContrastAdjustmentFilter; that is essentially a postprocessor filter GLSL API that controls the 3D-color-gamut contrast using a power law, and was introduced in jMonkeyEngine v3.5.0-beta4.

• Writing JavaDoc for an Old Animation System (MonkeyAnim): I’ve taken the initiative in writing JavaDocs for a 7-year-old undocumented and vague animation system (MonkeyAnim), and succeeded with the team guidance to deliver some of it on the currently working release jMonkeyEngine v3.7.0.

• Issues support and Community Management participations: Other things that I had worked on in jMonkeyEngine are issues related to the Android jme3-android and the core modules jme3-core.

• Beginnings of the Serial4j framework: I designed Serial4j back in 2021, a Java Terminal I/O framework for serial interfaces (e.g., Serial USB and RS232) based on the Data-Flow and the Data-centered architectural designs, in which I’ve blended a lot of my skills, including but not limited to, developing APIs using C/C++, building dynamic native libraries, using Gradle and CMake to build JNI applications, testing memory leaks, designing and implementing modal logic algorithms and byte-flow patterns, hardware/software co-design, plus introducing a vision for distributed simulation systems.

---

Pi4j Contributions:

Technical Writing | (2022)

Upon the request of one of the Pi4j community leader, I’ve published a hybrid project that utilizes both Pi4j-v1 and jMonkeyEngine framework as a Pi4j-featured project; in which I presented a full tutorial on hooking an Analog-Digital Circuit (MCP3008) onto the RPI GPIO through the Serial-Peripheral Interface (SPI) protocol. The tutorial also adds insights on the generic circuits and the conceptual model behind ADCs and DACs circuits.

---

Electrostat-Lab Open-source Contributions:

OSS Embedded and Android Projects | (2020 - Present)

During the last 2 years, I’ve started my own open-source projects at Electrostat-Lab organization.

Development at Electrostat-Lab:

Electrostat-Lab projects tend to solve problems arising within different domains, mainly jMonkeyEngine community, and my unfinished game JPluto Arcade Game; which should utilize a wide aspect of Hardware/Software Co-design, so typically the rendering and physics pipelines are managed using jMonkeyEngine interfaces, while the controller interfaces are built using custom peripherals and interfaced over serial and networks.

The vision of this organization:

The current vision of the Electrostat-Lab organization is to provide a fully-fledged POSIX-based Open-Source Distributed Simulation Framework; and it does this perfectly by dividing the framework into several smaller frameworks and APIs of re-usable code.

---

Gradle first exposure:

Discussions on GitHub | (2023)

My first exposure to the Gradle team was providing an explanation to an issue with the JavaDoc tooling and this PR, particularly using the --release ${V} option with the JavaDoc tool. However, I haven’t got the time enough to communicate with the team and provide a fix, in addition, the team had replied back that it might take a long delay time to proceed.

Projects:

My projects are located on the Electrostat-Lab GitHub organization. You can find them by typing electrostat-lab in the search to search for repositories with this tag. Of which, those are the most coolest projects that I’ve:

Gradle-At-A-Glance

GitHub - Overview Video

Description: A critique project for the current Gradle Framework on the gradle/gradle repository featuring the Gradle platform modules and infrastructure, in addition to a fair comparison to a design of a home-made similar project using the System-Entity-Structure/Model-Base Framework (SES/MB) for Modelling and Simulation, and the Tricotyledon Theory of System Design (T3SD), known as “Ccoffee”. Ccoffee is a provisional conceptual design for a virtual project written purely in the C programming language even providing services for hardware compatibility (i.e., Microcontrollers). The project is subdivided into multiple modules; where each module represents a collective solution for a sub-problem in the problems domain with a strong abstractive layer featuring the Hierarchial patterns, such that, the solution range involves filesystem module, connection-handler module, and infrastructure module.

Features:

• Agnostic Build: The most headache-producing part in Native project development is the building stage which is platform-specific, and it could be eliminated by using the POSIX interfaces and providing a clear way to pilot-building the project by itself using a wrapper API; which compiles, builds, and caches the project binaries for a faster second run.
• Robust Discrete Architecture: According to the software ontology involved, the filesystem module deals with the primitive filesystems operations and is subdivided internally to a couple of API; FileGenerator component, FileLocator component, FileEditor component, FileExtractor component, and FileUtils component for extra manipulation, while the connection-handler module is devoted to provide the basis for the RESTful APIs, and is basically composed of ConnectionEstablishmentHandler component, ConnectionMonitorHandler component, ConnectionInputStreamHandler component, ConnectionOutputStreamHandler component, and ConnectionListeners component, and part of this might be categorized as a specialization of the filesystem APIs (i.e., depends-on/assembly relationship).
• Port to Embedded Systems and superiority over the Gradle Binaries: Essentially, the beneficence of using the C programming langauge and the GNU C Collection is that it provides the ability to ship the project or at least the most relevant parts of it to run on bare-metal RISC MCUs (e.g., the AVR ATMega32) which is superior to the current Gradle and other building tools like CMake, but a clear usage for this feature is not fully studied, yet.

Tools: Java SE Platform - Gradle Plugin API - Plant UML Component Diagraphs - Intellij IDEA - Sonatype Maven Central.

GDude Gradle Plugin

WIP

GMake Gradle Plugin

WIP

jSnapLoader API

GitHub - Maven-central

Description: A high-performance platform-independent Native Dynamic Library extractor and loader for JVM and Android Applications based on the Data-Flow and the Hierarchial Architectural patterns.

Features:

• Platform-specific dynamic libraries’ registration.
• Platform-specific dynamic libraries building using platform-specific predicates.
• Locate and load external dynamic libraries directly.
• File Locator and extractor routines (classpath - external jar).
• Extract native libraries from the stock jar library (classpath).
• Locate external jars and extract native libraries from them.
• Define an extract directory path.
• Retry Criterion with clean extraction.
• EventDispatchers: Extraction Listeners, Loading Listeners, and System Detection Listeners.
• Filesystem Failure Throwable Exceptions: binds the user API to the jSnapLoader lifecycle.
• Tight handling of memory leaks; as a result of file locator and/or file extractor failures.
• Memory logging of the stream providers’ handlers using the object hash keys.
• Assets extraction through the Filesystem API (e.g., gltf files and images).

Robust Discrete Architecture: The architecture basically divides the library into subsets of APIs; each of them solves a subset problem of the major problem. The library solves the most headache-producing problem in developing cross-platform native applications; which is creating predicates for each system in the form of nested conditional statements, this library solves the problem using formula objects known as PlatformPredicates, which are formed of P(X) = (OS && CPU && ARCH), and thus new PlatformPredicates could be built on the user application side and not primarily hard-coded into the main API leading to a robust design with simple ideas picked from Discrete Mathematics and Modal Logic. Additionally, the framework offers a stock onloading anti-failure mechanism, and a stepwise command-state pattern to handle failures from the user application side enabling the implementation of several anti-failure routines from the user side. Furthermore, memory logging and tight handling of stream resources are attained on both the normal program flow and the exceptional cases (i.e., failure cases). The framework is open-ended for user-based specializations and wrappers APIs.

Used by: The framework is currently deployed to be used by Jolt-jni, Serial4j, and Electrostatic4j.

Serial4j Framework

GitHub - TechDemo

Description: A Java terminal IO framework based on the GNU/Linux termios API for communication with peripheral devices using the serial interface (e.g., USB Serial, RS232, and PS/2).

Architecture: The base architecture of Serial4j is based on the Data-Flow Systems, particularly Pipe-and-Filter Architectural design, so from a low-level perspective, the Filesystems and byte streams, which is very analogus conceptually to serialization and deserialization, but on wire. The pipe is the plain filesystem and byte streams, while the filters are composed of main stream filters imposed by the operating system; that is the Terminal, that controls the byte streams providing buffered, unbuffered, and line feed/return carriage buffered stream routines. Other filters are mutually exclusive parts of the architecture known as Human-Interface-Device APIs and SerialMonitor APIs; those provide new routines to manipulate byte streams as Data Frames; so essentially introducing a new type of buffered streams through accumulating data via modal logic (or boolean algebra aka. bitwise operations). The framework was designed essentially to provide innovators with custom controllers to bind to jMonkeyEngine Game Lifecycle for Kiosk-based systems.

Features:

• Hierarchial modular architecture in structure separating the native libraries from the Java APIs.
• Cross-platform capabilities on POSIX interfaces.
• Low-level File I/O APIs with java.io APIs specializations integratable with other applications.
• Full terminal control modes for serial-based file I/O interpreted directly from the GNU/Linux POSIX APIs.
• Serial Human-Interface-Device (HID) API providing specializations for serial-based devices signifying the read() and write() operations and providing preprocessing and postprocessing filtering techniques for encoding, decoding, and encryption/decryption algorithms.
• jMonkeyEngine integration examples with realtime data monitoring.

Tools: Java SE Platform - C/C++ - CMake - Gradle - GNU/Linux Libc - ShiftAvr - WSL - Maven central.

GMonitor Gradle Plugin

GitHub - TechDemo - Maven-central

Description: Creates a portable Serial Monitor plugin to be used beside embedded systems applications on embedded linux machines and the raspberry pi through integrating the Serial4j framework into the Gradle Framework via a Gradle Plugin that distributes the jobs of the Serial4j Serial Monitor into Gradle tasks.

Features:

• Starts a continous serial monitor session on a port of user selection.
• Supports jMonkeyEngine application integration controls out-of-the-box.
• Dynamically changeable baud rate, file modes, and terminal modes.
• Anti-failure detection and anti-failure routines through the legacy exception handling.
• Layered architecture separating the concurrency and thread-dependent APIs from the terminal, low-level I/O, serial monitor, and HID APIs.
• Deployed for x86, x86-64, arm32, and arm64 systems as distributed dependencies on maven-central.

Tools: Java SE Platform - Gradle Plugins API - Serial4j Framework - Maven Central - Intellij IDEA

Jector Framework

GitHub - TechDemo - Maven-central

Description: An advanced DI framework for JVM and Android applications based on the Java Reflection API with a specialized implementation for jMonkeyEngine Applications.

Features: Jector provides a programming concurrent (order-parallelism/sync) model for best practices by injecting functions’ stacks into schedulable tasks, and in turn into their designated threads. Threads can be activated and controlled to achieve either parallelism or synchronicity. Its threading model could be used for assets asynchronous loading, async tasks execution, and mutual multithreading (threading using mutual events).

Tools: Java SE Platform - Gradle - jMonkeyEngine Framework.

Articular-ES Framework

GitHub - TechDemo - Maven-central

Description: An entity component system (ECS) framework featuring strong articulations among components from different systems through controller interfaces. The API is powered by a caching system that enables caching data in different configurations. Operational interactions take place within the system manager through the controller objects.

Architecture: The API provides a strong abstraction based on the data-centered architecture with the ability to model complex systems, such as: Human Interface Devices (HID) APIs, and language processing and translational APIs. The framework is composed structurally of Systems, Entities, Modules, and Components, while behaviorly of SystemControllers and DataPipes.

Features:

Tools: Java SE Platform - Gradle - Entity-Component-System Architecture - jMonkeyEngine Framework - GitHub Actions (CI/CD).

Automata4j Framework

GitHub - TechDemo - Maven-central

Description and features: A classic finite-states-automata (FSA) framework for JVM and Android applications featuring both the Deterministic Finite Automata (DFA) and the Non-deterministic Finite Automata (NDFA) together with the ability to cache states beforehand in finite-automata aggregates, through the CascadedTransition components, a type of finite-states transition path that superimposes cascaded paths through abstract Queue data structures.

Game-HCI

GitHub - TechDemo1 - TechDemo2 - Jitpack-io

Description: An Android API housing useful re-usbable Human-computer Interfaces (HCI) in the form of in-game android views with an integration API for jMonkeyEngine featuring the Model-View-Controller (MVC) Architecture for designing GUI components and providing a binding API to the jMonkeyEngine Lifecycle.

Features: The API has a couple of ready-to-use components, including but not limited to, a GameStickView component and a ControllerButtonsView component, a DrivingWheelView component, a GullWing component for spacecrafts, a Tachometer and a UTurnView generically for vehicles, plus other Android Menustate items. The API is available on Jitpack-io for public use.

Electrostatic-Sandbox SDK Suite (WIP)

GitHub - Website

Description: A work-in-progress open-source code-first complete SDK and development suite for distributed simulation systems based on the IEEE-1516 High-level Architecture Interface, GNU/Linux Kernel userspace APIs, and NASA DSES. The infrastructure of the sytem is subdivided into Networking Infrastructure, Software Infrastructure, and Simulation Infrastructure.

Architecture: Essentially, the Networking Infrastructure is composed of a common communication protocol API abstracting off the different serial and parallel communication cores (e.g., TCP/IP, Serial Interfaces RS232 Standard and USB Standard, Parallel Standard IEEE-1284 or Centronics, Ethernet Standard IEEE-802.3), the Software Infrastructure is composed mainly of the firewall APIs, the database APIs, and the rest of operating system resources handler APIs (e.g., MemoryManagers and WindowManagers) in addition to the Runtime Infrastructure (RTI) and the RTI Interfaces defined by the HLA IEEE-1516 Standard for Distributed Simulation Systems.