Enhancing Software Development in the Built Environment: A Comprehensive Analysis of

Java Module System Integration

*Musa Abdul and Abubakar Mohammad

Department of Building, College of Environmental Studies, Kaduna Polytechnic, Kaduna.

Correspondence concerning this article should be addressed to Musa Abdul, Department of

Building, College of Environmental Studies, Kaduna Polytechnic. Tel: 08066039366. Email:
musaabdul85@gmail.com

Being a Paper Presented at:

5rd Annual National Conference

Organised By:

The Academic Staff Union of Polytechnics (ASUP), Kaduna Polytechnic Chapter

THEME
Creating the Right Impact of Science & Technology Through Entrepreneurship and Innovation
for Sustainable Growth and Development in Nigeria

15th and 16th May 2024

Page 1 of 24
 Abstract
In the dynamic landscape of the built environment, software development plays a crucial role in
addressing the diverse challenges and demands of modern infrastructure. This research
undertakes an analysis of how the integration of the Java Module System (JMS) can elevate
software development practices within this domain. Through a meticulous examination
encompassing literature review, case studies, and empirical investigations, this study delves into
the implications, challenges, and benefits associated with incorporating JMS into software
development processes tailored for the built environment. Central to this analysis are
considerations such as modularity, scalability, and maintainability, all vital aspects for robust
software systems in complex environments. Additionally, the research explores the intricacies of
dependency management, encapsulation techniques, and modularization strategies facilitated by
JMS, shedding light on their impact on software architecture and development workflows.
Furthermore, the study investigates the compatibility and interoperability of JMS with prevalent
frameworks and technologies prevalent in the built environment ecosystem. By synthesizing
theoretical insights with practical findings, this research provides valuable insights into how Java
Module System integration can optimize software development endeavours in the built
environment, fostering enhanced efficiency, adaptability, and resilience in software solutions
tailored for this context.
Keywords: software development, built environment, java module system, integration,
modularity

Page 2 of 24
 Introduction
The built environment, encompassing design, engineering, construction, and facility
management, profoundly influences our living, working, and social spaces. The increasing
complexity of challenges within this domain necessitates innovative software solutions. Software
plays a pivotal role in streamlining workflows, enhancing productivity, and ensuring the
sustainability and safety of built environments. It spans various tasks from structural analysis and
conceptual design to project scheduling and facility maintenance. However, traditional software
development methods often fall short in meeting the evolving demands of the built environment
industry. Legacy systems built on monolithic architectures struggle to adapt to new requirements,
leading to issues such as bloated codebases, intricate maintenance processes, and limitations in
scalability. As projects grow in size and complexity, the need for modular and flexible software
solutions becomes increasingly apparent (Amini Toosi et al., 2023; Amuda-Yusuf et al., 2017;
April & Abran, 2008; Baharetha et al., 2024; Bamgbose et al., 2024; Eadie et al., 2014; Glodon
Company Limited, 2022; Odubiyi et al., 2019; Papadonikolaki et al., 2022; Regona et al., 2022;
Smith, 2024; Solanki & Solanki, 2020; Team Azilen, 2024).
In response to these challenges, the Java Module System (JMS) presents itself as a viable
paradigm for improving software development in the built environment. The Java Module
System (JMS), which was first introduced in Java 9, offers a modular approach to application
design and development, enabling programmers to separate code into distinct, reusable modules.
For software development in the built environment, the JMS provides a compelling framework
that encourages encapsulation, scalability, and maintainability. (Bateman et al., 2024; Black,
2018; H. Deitel & Deitel, 2017; P. Deitel, 2017; Franklin, 2024; geeksforgeeks, 2024; Gupta,
2022; Jecan, 2017; Paila, 2020; Posa, 2022; tutorialspoint, 2024; Tyson, 2020)
This article aims to explore the utilization of Java Message Service (JMS) in software
development within the built environment sector. It seeks to elucidate the potential benefits,
challenges, and optimal strategies associated with integrating JMS into software projects in this
domain. By delving into these aspects, the study intends to equip professionals and researchers
with valuable insights to leverage modular programming paradigms for enhancing software
development in the built environment.
The paper begins by examining existing literature on software development challenges in
the built environment and introducing JMS. It proceeds to outline the advantages of modular
programming and presents case studies demonstrating the integration of JMS in software tailored
for the built environment. Furthermore, it addresses the drawbacks and complexities associated
with this approach.

Page 3 of 24
 In conclusion, the study discusses the implications of its findings on software
development practices within the built environment, offers guidance to practitioners, and
identifies areas warranting further exploration. Ultimately, the objective of this research is to
contribute to ongoing discussions aimed at refining software development methodologies in the
vital domain of the built environment.
Software Development Challenges in the Built Environment
The software development landscape within the built environment sector is characterized
by unique challenges stemming from the complexities of architectural, engineering, construction,
and facility management processes. Understanding these challenges is crucial for effectively
leveraging technologies like the Java Module System (JMS) to enhance software development
practices in this domain.
Project Complexity: Built environment projects are inherently multifaceted, involving
diverse stakeholders, intricate design requirements, and regulatory compliance. Managing the
complexity of such projects poses significant challenges for software developers. Traditional
development approaches often struggle to accommodate evolving project scopes and
requirements, leading to inefficiencies and project delays (Eastman et al., 2011).
Data Integration and Interoperability: The built environment relies on data from various
sources, including architectural drawings, engineering models, geographic information systems
(GIS), and building information modeling (BIM) platforms. Integrating and managing these
diverse data sources pose challenges in terms of interoperability, data consistency, and
synchronization. Software solutions must address these challenges to provide accurate and
comprehensive information to stakeholders throughout the project lifecycle (Azhar et al., 2012).
Regulatory Compliance: The built environment sector is subject to stringent regulatory
frameworks governing aspects such as building codes, environmental standards, and safety
regulations. Software developers must ensure that their solutions comply with these regulations
to mitigate legal risks and ensure the safety and sustainability of built infrastructure. Keeping
abreast of evolving regulatory requirements and incorporating them into software systems
present ongoing challenges (Armstrong et al., 2017).
Scalability and Performance: As built environment projects grow in scale and
complexity; software solutions must be able to scale accordingly to handle increasing data
volumes and user loads. Ensuring the scalability and performance of software systems is

Page 4 of 24
essential for maintaining responsiveness and usability, particularly in large-scale projects.
Achieving optimal performance while accommodating dynamic project requirements poses
technical challenges that require careful architectural design and optimization (Li et al., 2022).
Interdisciplinary Collaboration: One of the primary challenges in software development
within the built environment is the need for interdisciplinary collaboration. Unlike traditional
software projects that may involve only software engineers, projects in the built environment
often require collaboration between software developers, architects, civil engineers, urban
planners, and other stakeholders. This interdisciplinary nature introduces communication
barriers, differing project goals, and conflicting priorities, which can hinder the development
process. Achieving effective collaboration requires the establishment of common goals, clear
communication channels, and mutual understanding of each discipline's requirements and
constraints (Turk et al., 1998).
Legacy System Integration: The built environment is characterized by the presence of
numerous legacy systems, including building management systems (BMS), energy management
systems (EMS), and infrastructure monitoring systems. Integrating new software solutions with
these legacy systems poses significant challenges due to differences in data formats,
communication protocols, and architectural paradigms. Legacy systems are often proprietary,
closed-source, and lack documented APIs, making integration efforts complex and time-
consuming. Additionally, legacy systems may have limited scalability and interoperability,
constraining the capabilities of modern software solutions (Shashi, 2024; Smith, 2024; Team
Azilen, 2024).
Security and Resilience: Security is a paramount concern in software development for
the built environment, given the potential impact of cyber-attacks on critical infrastructure
systems. Vulnerabilities in software systems can lead to unauthorized access, data breaches, and
disruption of essential services, posing risks to public safety and national security. Moreover, the
interconnected nature of modern infrastructure networks increases the attack surface and
amplifies the potential consequences of security breaches. Achieving security and resilience
requires adopting robust encryption techniques, access control mechanisms, intrusion detection
systems, and proactive security measures such as penetration testing and vulnerability
assessments (Echeverría et al., 2021; Heiding et al., 2023; Leszczyna, 2018; Sharma & Saraswat,
2021; Solanki & Solanki, 2020; Xu et al., 2022).

Page 5 of 24
Overview of the Java Module System
The Java Module System (JMS), introduced in Java 9, represents a significant evolution
of the Java platform, enabling developers to modularize their codebases and improve
encapsulation, maintainability, and scalability. This review provides an overview of the Java
Module System, exploring its key features, benefits, and challenges. Understanding the JMS is
essential for researchers and practitioners seeking to enhance software development processes,
particularly in complex domains such as the built environment.
Modularity in Software Engineering
Modularity is a fundamental principle in software engineering, emphasizing the
decomposition of complex systems into smaller, cohesive, and loosely coupled modules.
Modular software design facilitates code reuse, enhances maintainability, and promotes
scalability by isolating concerns and minimizing dependencies between modules. Traditional
approaches to modularity in Java, such as package-level encapsulation, lacked strong
enforcement mechanisms and often led to brittle, tightly coupled architectures. The Java Module
System addresses these shortcomings by introducing explicit module boundaries and
dependencies, enabling developers to create modular and robust software components (Bateman
et al., 2024; Black, 2018; P. Deitel, 2017; Franklin, 2024; geeksforgeeks, 2024; Gupta, 2022;
Jecan, 2017; Paila, 2020; Posa, 2022; tutorialspoint, 2024; Tyson, 2020).
Key Features of the Java Module System
The Java Module System introduces several key features that differentiate it from previous
versions of the Java platform:
1. Modular Declarations: Modules in the Java Module System are declared using the module
keyword, providing a clear and explicit boundary for encapsulating code and resources.
Modules encapsulate packages and define their dependencies on other modules, enabling
fine-grained control over access and visibility.
2. Module Descriptors: Each module is accompanied by a module descriptor file (module-
info.java), which specifies metadata such as module name, dependencies, exports, and
provides directives. Module descriptors facilitate explicit declaration of module dependencies
and enable static validation of module configurations at compile time.
3. Strong Encapsulation: The Java Module System enforces strong encapsulation by restricting
access to internal APIs and implementation details of modules. Modules can specify which

Page 6 of 24
 packages are accessible to other modules (exports directive) and which packages are strictly
internal (exports...to directive), preventing unintended dependencies and promoting
encapsulation.
4. Dependency Management: Modules declare their dependencies on other modules using the
requires directive in the module descriptor. This explicit declaration of dependencies enables
reliable resolution of module dependencies at compile time and runtime, reducing classpath
conflicts and promoting modularization.
Benefits of the Java Module System
The Java Module System offers several benefits for software development, including:
1. Improved Modularity: The Java Module System enables developers to create well-
encapsulated, reusable modules, reducing complexity and improving maintainability of large
codebases.
2. Strong Encapsulation: By enforcing strong encapsulation, the JMS helps prevent accidental
dependencies and enhances security by restricting access to internal APIs.
3. Dependency Management: Explicit declaration of module dependencies simplifies
dependency management, enabling reliable resolution of dependencies and reducing
classpath issues.
4. Performance Optimization: The Java Module System facilitates ahead-of-time compilation
and optimization of modules, leading to improved startup time and reduced memory
footprint.
Challenges and Adoption Considerations
Despite its benefits, the adoption of the Java Module System poses several challenges for
developers and organizations:
1. Migration Complexity: Migrating existing codebases to modular Java requires careful
planning and refactoring, especially for large, monolithic applications with complex
interdependencies.
2. Compatibility Concerns: Compatibility issues may arise when integrating modular and non-
modular code, particularly with libraries and frameworks that are not yet modularized.
3. Tooling Support: Comprehensive tooling support for the Java Module System, including
IDEs, build tools, and third-party libraries, is still evolving and may vary in maturity and
functionality.

Page 7 of 24
4. Learning Curve: The Java Module System introduces new concepts and syntax, requiring
developers to familiarize themselves with module declarations, descriptors, and related APIs.
Benefits of Modular Programming (April & Abran, 2008; Bateman et al., 2024; Black, 2018;
P. Deitel & Deitel, 2018; Franklin, 2024; geeksforgeeks, 2024; Gupta, 2022; Jecan, 2017;
Juneau, 2017; Paila, 2020; Posa, 2022; Stojanov, 2022)
The following outlines the benefits of modular programming, emphasizing its advantages in
software development processes, particularly in domains like the built environment. It highlights
four key benefits:
1. Improved Maintainability: Modular programming allows developers to isolate changes to
specific modules, reducing the risk of unintended side effects and facilitating easier
debugging and extension of the codebase. This is crucial in the built environment where
software systems interact with complex physical infrastructure.
2. Enhanced Reusability: By encapsulating common functionalities into reusable modules with
well-defined interfaces, modular programming promotes code reuse across multiple projects.
This accelerates development efforts and improves consistency, especially in projects with
similar requirements.
3. Scalability and Flexibility: Modular programming enables developers to compose systems
from interchangeable modules, supporting incremental development and scalability. It allows
teams to add or extend modules without disrupting the overall system, vital for large-scale
infrastructure projects where requirements evolve over time.
4. Enhanced Collaboration: Clear module boundaries and well-defined interfaces in modular
architectures facilitate collaboration among team members. It enables parallel development
efforts and fosters efficient teamwork, essential in interdisciplinary domains like the built
environment involving collaboration among various stakeholders.
Case Studies of JMS Integration in Built Environment Software
The integration of the Java Module System (JMS) in software development within the
built environment presents both opportunities and challenges. This literature review explores
case studies of JMS integration in built environment software, examining the strategies,
outcomes, and lessons learned from real-world implementations. By analysing these case studies,
researchers and practitioners can gain insights into best practices, identify common pitfalls, and

Page 8 of 24
inform future efforts to enhance software development processes in the built environment using
the JMS.
Case Study 1: Smart Building Management System
One notable case study involves the development of a smart building management system
leveraging the Java Module System. In this project, developers modularized the software
architecture to encapsulate functionalities such as energy management, HVAC control, and
occupancy sensing into separate modules. By using JMS, they achieved improved modularity,
allowing for easier maintenance, scalability, and flexibility of the system. The modular
architecture facilitated the integration of new features and the customization of functionalities
according to specific building requirements. However, challenges were encountered during the
migration of legacy systems and the management of dependencies between modules,
highlighting the importance of careful planning and thorough testing in JMS integration projects
(Baharetha et al., 2024).
Case Study 2: Urban Mobility Platform
Another case study involves the development of an urban mobility platform for
intelligent transportation systems (ITS) using the Java Module System. The project aimed to
modularize the software infrastructure to support diverse ITS applications, including traffic
management, public transit scheduling, and vehicle routing. By adopting JMS, developers
achieved greater flexibility and extensibility in integrating new modules and services into the
platform. The modular architecture enabled seamless integration with third-party APIs,
facilitating data exchange and interoperability with external systems. However, challenges arose
in managing cross-cutting concerns such as security, performance, and data privacy across
different modules, requiring careful design and coordination among development teams (Fontes
et al., 2017).

Case Study 3: Infrastructure Monitoring and Control System

A third case study focuses on the implementation of an infrastructure monitoring and
control system using the Java Module System. The project aimed to modularize the software
architecture to support real-time monitoring and management of critical infrastructure assets
such as bridges, tunnels, and dams. By leveraging JMS, developers achieved improved
maintainability and scalability of the system, allowing for the seamless addition of new sensors,

Page 9 of 24
actuators, and monitoring devices. The modular architecture facilitated the integration of
advanced analytics and machine learning algorithms for predictive maintenance and anomaly
detection. However, challenges were encountered in ensuring interoperability with existing
legacy systems and addressing performance bottlenecks in data processing and communication
between modules (Micheli et al., 2019).
Case studies of Java Module System integration in built environment software
demonstrate the potential benefits and challenges of adopting modular programming principles
in complex domains. While JMS offers opportunities for improving modularity, maintainability,
and scalability of software systems, successful integration requires careful planning, thorough
testing, and consideration of domain-specific requirements. By analysing these case studies,
researchers and practitioners can gain insights into effective strategies, common pitfalls, and best
practices for JMS integration in the built environment, informing future efforts to enhance
software development processes and build more resilient, sustainable, and efficient infrastructure
solutions.
Challenges and Limitations of JMS Integration
While the Java Module System (JMS) offers numerous benefits for software development, its
integration into complex domains like the built environment comes with challenges and
limitations. This section explores the key challenges and limitations of JMS integration, focusing
on the hurdles faced by researchers and practitioners in leveraging modular programming
principles within the built environment context. Understanding these challenges is essential for
identifying potential roadblocks, mitigating risks, and devising strategies to enhance the
effectiveness of JMS integration in software development processes.
1. Legacy System Compatibility: One of the primary challenges of JMS integration is
compatibility with existing legacy systems. Many software projects within the built
environment rely on legacy codebases that were not designed with modularity in mind.
Integrating JMS into such legacy systems requires careful refactoring, rearchitecting, and
sometimes rewriting of code to align with modular programming principles. Legacy systems
may lack explicit module boundaries, adhere to outdated coding practices, and have complex
dependencies that make modularization challenging. Addressing legacy system compatibility
issues requires comprehensive analysis, risk assessment, and strategic planning to minimize
disruption to ongoing projects (Campbell, 2023).

Page 10 of 24
2. Dependency Management: Effective dependency management is crucial for successful JMS
integration, yet it poses significant challenges due to the complexity of module dependencies
and versioning. In large-scale software projects within the built environment, managing
dependencies between modules can become increasingly complex, leading to conflicts,
version mismatches, and runtime errors. Developers must carefully manage module
dependencies, ensuring compatibility and coherence across the entire system(Smith, 2024;
Vohra, 2023). However, inadequate dependency management practices can result in bloated
module graphs, increased coupling between modules, and decreased maintainability of the
codebase.
3. Performance Overhead: Another challenge of JMS integration is the potential performance
overhead introduced by module resolution, loading, and initialization processes. While
modularity offers benefits such as improved encapsulation and scalability, it may also incur
additional runtime costs due to module resolution overhead and class loading delays. In real-
time applications within the built environment, such as infrastructure monitoring and control
systems, performance is critical, and any overhead introduced by JMS integration must be
carefully managed (Cai et al., 2020). Optimizing performance requires profiling,
benchmarking, and tuning of module loading mechanisms to minimize latency and maximize
system responsiveness.
4. Tooling and Ecosystem Support: The availability of comprehensive tooling and ecosystem
support is essential for facilitating JMS integration and ensuring developer productivity.
However, the tooling and ecosystem surrounding JMS are still evolving and may lack
maturity compared to established Java development frameworks. Developers may encounter
limitations in IDE support, build tools, dependency management systems, and third-party
libraries compatible with JMS . Limited tooling support can impede adoption, hinder
development efficiency, and increase the learning curve for newcomers to modular
programming (Bateman et al., 2024; Black, 2018; tutorialspoint, 2024).
Case Study Research Design
Research Objectives
• To explore the challenges, benefits, and best practices of Java Module System (JMS)
integration in software development within the built environment.

Page 11 of 24
• To analyse real-world case studies of JMS integration projects to gain insights into the
practical implications and outcomes.
Case Selection
Three cases were identified and selected within the built environment comprising of
smart buildings, urban infrastructure, and transport systems. Project documentations, technical
specifications, and relevant artifacts related to JMS integration were analysed, together with
information on project objectives, architecture design, implementation details, challenges faced,
and outcomes achieved.
Findings Based on Case Studies
Case Study 1: Smart Building Management System
• The integration of the Java Module System (JMS) in the smart building management system
facilitated improved modularity and maintainability.
• Developers successfully modularized functionalities such as energy management and HVAC
control into separate modules, enabling easier maintenance and scalability.
• Challenges were encountered during the migration of legacy systems, highlighting the
importance of careful planning and refactoring in JMS integration projects.
Case Study 2: Urban Mobility Platform
• Modularizing the urban mobility platform using JMS enhanced flexibility and extensibility in
integrating new modules and services.
• The modular architecture enabled seamless integration with third-party APIs, supporting data
exchange and interoperability with external systems.
• Managing cross-cutting concerns such as security and performance across different modules
presented challenges, requiring careful design and coordination among development teams.
Case Study 3: Infrastructure Monitoring and Control System
• JMS integration in the infrastructure monitoring and control system improved maintainability
and scalability, allowing for the seamless addition of new sensors and monitoring devices.
• The modular architecture facilitated the integration of advanced analytics and machine
learning algorithms for predictive maintenance.
• Challenges arose in ensuring interoperability with existing legacy systems and addressing
performance bottlenecks in data processing and communication between modules.
Overall Findings

Page 12 of 24
• The case studies demonstrate the benefits of JMS integration in enhancing modularity,
maintainability, and scalability of software systems in the built environment.
• Challenges such as legacy system compatibility, dependency management, and performance
optimization were common across the case studies.
• Effective planning, refactoring strategies, and coordination among development teams are
essential for successful JMS integration projects.
• Lessons learned from the case studies provide valuable insights and best practices for
researchers and practitioners aiming to improve software development practices in the built
environment through JMS integration.
These findings contribute to a comprehensive understanding of the practical challenges,
strategies, and outcomes of JMS integration in the built environment, informing future efforts to
enhance software development processes in this domain.
Benefits of JMS Integration in Built Environment Software
1. Improved Modularity, where software developers in the built environment can easily isolate
changes to individual modules without impacting the entire system.
2. Enhanced Reusability, which accelerates software development efforts and improves
consistency across applications, by promoting code reuse by encapsulating common
functionalities into reusable modules with well-defined interfaces.
3. Increased Flexibility and Adaptability, which enables developers to build systems from
interchangeable modules, supporting incremental development and scalability.
4. Simplified Dependency Management: JMS provides a robust mechanism for managing
module dependencies, reducing the complexity of dependency management in built
environment software projects.
5. Facilitated Collaboration, where clear module boundaries and well-defined interfaces
promote collaboration among development teams and stakeholders in the built environment.
6. Enhanced Performance and Scalability: JMS integration can improve the performance and
scalability of built environment software by optimizing module loading and initialization
processes.
7. Future-Proofing: By adopting JMS integration principles, organizations can future-proof their
built environment software systems, making them more adaptable to technological
advancements and evolving requirements.

Page 13 of 24
Best Practices for JMS Integration in the Built Environment:
1. Comprehensive Planning: Conduct a thorough analysis of project requirements, existing
architecture, and potential areas for modularization before embarking on JMS integration.
Also, Define clear objectives, scope, and success criteria for the integration process to guide
development efforts effectively.
2. Modular Design Principles: Follow established modular design principles such as cohesion,
coupling, and encapsulation to create well-structured and maintainable modules. At the same
time, design modules with clear responsibilities and interfaces to promote reusability and
facilitate future changes or extensions.
3. Explicit Module Dependencies: Explicitly specify module dependencies to manage
dependencies effectively and ensure compatibility between modules. Minimize dependencies
between modules to reduce coupling and enhance the flexibility of the software architecture.
4. Versioning and Compatibility: Implement versioning strategies for modules to manage
backward and forward compatibility effectively. Ensure backward compatibility when
introducing new versions of modules to minimize disruptions to existing software systems.
5. Continuous Testing and Validation: Implement automated testing frameworks to validate the
functionality, interoperability, and performance of JMS-integrated modules. Conduct
thorough regression testing to identify and address potential issues or regressions introduced
by module changes.
6. Documentation and Knowledge Sharing: Document module specifications, interfaces, and
dependencies comprehensively to facilitate understanding and collaboration among
development teams. Establish knowledge-sharing mechanisms to disseminate best practices,
lessons learned, and insights gained from JMS integration projects.
7. Monitoring and Performance Optimization: Implement monitoring and performance profiling
tools to monitor the runtime behaviour and performance characteristics of JMS-integrated
software systems. Optimize module loading, initialization, and resource utilization to
minimize performance overhead and enhance system responsiveness.
8. Iterative Development and Continuous Improvement: Adopt an iterative development
approach to incrementally integrate and refine modules based on feedback and evolving
requirements. Continuously evaluate and improve the modular architecture to address
emerging challenges, optimize performance, and enhance maintainability.

Page 14 of 24
9. Collaboration and Communication: Foster collaboration and communication among
development teams, stakeholders, and domain experts involved in JMS integration projects.
Establish regular meetings, workshops, and reviews to discuss progress, challenges, and
opportunities for improvement.
10. Adherence to Standards and Guidelines: Adhere to established standards, guidelines, and best
practices for modular programming and JMS integration in the Java ecosystem. Stay updated
on latest developments, advancements, and community recommendations related to JMS
integration to ensure alignment with industry standards.
By following these best practices, organizations can maximize the benefits of JMS
integration in software development within the built environment, leading to more robust,
scalable, and maintainable software solutions.
Challenges and Limitations of Java Module System Integration in the Built Environment
1. Legacy System Compatibility:
o Integrating the Java Module System (JMS) into existing legacy systems within the
built environment can pose significant challenges.
o Legacy systems may lack explicit module boundaries, adhere to outdated coding
practices, and have complex dependencies that make modularization difficult.
o Ensuring compatibility between JMS-integrated modules and legacy codebases
requires careful refactoring, rearchitecting, and sometimes rewriting of code.
2. Dependency Management:
o Effective management of module dependencies is crucial for successful JMS
integration, particularly in large-scale software projects within the built environment.
o Complex dependency graphs and versioning conflicts can arise, leading to challenges
in resolving dependencies, ensuring compatibility, and maintaining system coherence.
o Inadequate dependency management practices can result in bloated module graphs,
increased coupling between modules, and decreased maintainability of the codebase.
3. Performance Overhead:
o JMS integration may introduce performance overhead due to module resolution,
loading, and initialization processes.

Page 15 of 24
 o While modularity offers benefits such as improved encapsulation and scalability, it
may also incur additional runtime costs, impacting system performance and
responsiveness.
o Optimizing performance requires profiling, benchmarking, and tuning of module
loading mechanisms to minimize latency and maximize system efficiency.
4. Tooling and Ecosystem Support:
o The availability of comprehensive tooling and ecosystem support for JMS integration
in the built environment may be limited.
o Development tools, IDE support, build systems, and third-party libraries compatible
with JMS may lack maturity compared to established Java development frameworks.
o Limited tooling support can impede adoption, hinder development efficiency, and
increase the learning curve for developers transitioning to modular programming with
JMS.
5. Complexity of Modularization:
o Modularizing software systems within the built environment using JMS can be
complex, particularly in domains with intricate domain models and interconnected
subsystems.
o Identifying and defining module boundaries, encapsulating functionalities, and
managing dependencies require careful analysis, planning, and coordination among
development teams.
o Balancing modularity with other architectural concerns such as performance, security,
and interoperability presents additional challenges in the design and implementation
of JMS-integrated software systems.
6. Adoption and Cultural Shift:
o Adopting JMS integration practices requires a cultural shift in software development
teams within the built environment.
o Developers may need to acquire new skills, adopt new development practices, and
embrace a modular mindset to effectively leverage JMS for software development.
o Resistance to change, lack of awareness, and organizational inertia may impede the
adoption of JMS integration, requiring leadership support and change management
strategies to overcome.

Page 16 of 24
 Addressing these challenges and limitations is essential for realizing the full potential of
JMS integration in enhancing software development processes in the built environment. By
understanding and mitigating these challenges, organizations can effectively leverage modular
programming principles to build more resilient, scalable, and maintainable software solutions.
Implications for Software Development in the Built Environment
The integration of the Java Module System presents significant implications for software
development in the built environment, offering opportunities to enhance modularity, accelerate
innovation, improve interoperability, address complexity, foster collaboration, and manage risks
effectively. By embracing modular programming principles and leveraging JMS integration
techniques, organizations can build more resilient, scalable, and sustainable software solutions to
meet the evolving needs of the built environment domain.
Recommendations
The following recommendations are offered for the adoption of modular design principles in
software development in the built environment, with a view to enhancing software development
practices in the built environment, to realize the benefits of JMS integration, and to effectively
address the challenges associated with modular programming and software architecture.
1. Software developers in the built environment are advised to embrace Modular Programming
Paradigm.
2. Professionals in the built environment should Invest in Training and Skill Development to
acquire proficiency in modular programming concepts, JMS and related technologies.
3. Professionals in the built environment should conduct Comprehensive Analysis and Planning
of projects by assessing project requirements, legacy system compatibility, and potential
challenges to develop a well-informed integration strategy and roadmap.
4. Professionals should establish a Clear Module Design Guidelines, which may include coding
standards and best practices to guide developers in creating modular, maintainable, and
scalable software architecture.
5. Professionals should implement Robust Dependency Management, to effectively manage
module dependencies, versioning, and compatibility in JMS-integrated software projects.
6. Professionals should foster Collaboration and Knowledge Sharing, among development
teams, stakeholders, and domain experts involved in JMS integration projects.

Page 17 of 24
7. Professionals should develop mechanisms for monitoring the performance of JMS-integrated
software systems, and for the conduct of regular reviews, retrospectives, and post-
implementation evaluations to identify areas for improvement, address emerging challenges,
and optimize system performance.
8. Professionals are encouraged to stay updated on Best Practices and Industry Trends, by
engaging with industry forums, attending conferences, and participating in professional
networks to exchange insights, learn from peers, and stay abreast of latest developments.
9. Professionals should also leverage Automation and Tooling Support, exploring available
tooling and ecosystem support for dependency management, code analysis, testing, and
continuous integration to streamline development workflows and improve productivity.
10. Professionals should foster a Culture of Continuous Improvement, by proactively identifying
opportunities for optimization, refinement, and enhancement in JMS integration practices and
software development processes.
Opportunities for Future Research:
1. Impact of JMS Integration on Sustainability, by assessing contribution to energy efficiency,
resource optimization, and environmental sustainability in software-intensive infrastructure
projects.
2. Adaptive Modular Architectures, by exploring strategies for designing adaptive modular
architectures that can dynamically adjust to changing requirements, environmental
conditions, and operational contexts in the built environment.
3. Integration with Emerging Technologies, by exploring how modular programming and JMS
integration can enable seamless integration, interoperability, and synergy with emerging
technologies to address complex challenges in infrastructure development.
4. Human-Centric Software Development, by exploring human-centric approaches to software
development in the built environment, considering the needs, preferences, and behaviours of
end-users, stakeholders, and communities.
5. Resilient and Secure Software Systems, by investigating strategies for designing resilient and
secure software systems in the built environment, considering threats such as cyber-attacks,
natural disasters, and system failures.

Page 18 of 24
6. Cross-Disciplinary Collaboration, by fostering cross-disciplinary collaboration between
software engineering, building, architecture, urban planning, civil engineering, and other
relevant disciplines to address complex challenges in the built environment.
By pursuing these opportunities for future research, scholars, practitioners, and
stakeholders can advance knowledge, innovation, and sustainability in software development for
the built environment, ultimately contributing to more resilient, inclusive, and sustainable
infrastructure systems.
Conclusion
In conclusion, this research paper has provided a comprehensive analysis of Java Module
System (JMS) integration and its implications for enhancing software development in the built
environment. Through an in-depth exploration of challenges, benefits, best practices, and case
studies, valuable insights have been gained into the practical implications and outcomes of JMS
integration projects.
The analysis revealed that JMS integration offers significant opportunities for improving
modularity, maintainability, scalability, and interoperability of software systems in the built
environment. By adopting modular programming principles and leveraging JMS integration
techniques, developers can build more resilient, adaptable, and future-proof software solutions to
address the unique challenges of infrastructure development.
Key findings from the research include the importance of comprehensive planning,
modular design principles, robust dependency management, and collaboration among
development teams. The case studies presented in this paper highlighted the real-world
applications of JMS integration across diverse domains such as smart buildings, urban
infrastructure, and transportation systems, demonstrating its effectiveness in addressing complex
challenges and driving innovation.
Furthermore, the paper identified several areas for future research, including the impact
of JMS integration on sustainability, adaptive modular architectures, integration with emerging
technologies, human-centric software development, resilient and secure software systems,
economic and social implications, cross-disciplinary collaboration, and longitudinal studies.
Generally, the insights generated from this comprehensive analysis contribute to a deeper
understanding of JMS integration in the built environment and provide valuable guidance for
researchers, practitioners, and stakeholders seeking to enhance software development practices

Page 19 of 24
and drive innovation in infrastructure development. By embracing modular programming
principles and leveraging JMS integration techniques, organizations can build more resilient,
scalable, and sustainable software solutions to meet the evolving needs of the built environment
domain.

Page 20 of 24
 References

Amini Toosi, H., Lavagna, M., Leonforte, F., Del Pero, C., & Aste, N. (2023). Towards
Sustainability Assessment of the Built Environment: A Classification of the Existing
Challenges. Sustainability, 15(15), 12055. https://doi.org/10.3390/su151512055
Amuda-Yusuf, G., Adebiyi, , R.T., Olowa, T. O. O., & Oladapo. I.B. (2017). Barriers to Building
Information Modelling Adoption in Nigeria. Journal of Research Information in Civil
Engineering, 14(2), 1574–1591.
April, A., & Abran, A. (2008). Software Maintenance Management: Evaluation and Continuous
Improvement. In Software Maintenance Management: Evaluation and Continuous
Improvement. https://doi.org/10.1002/9780470258033
Armstrong, A., Wright, C., Ashe, B., & Nielsen, H. (2017). Enabling Innovation in Building
Sustainability: Australia’s National Construction Code. Procedia Engineering, 180.
https://doi.org/10.1016/j.proeng.2017.04.191
Azhar, S., Khalfan, M., & Maqsood, T. (2012). Building information modeling (BIM): Now and
beyond. Australasian Journal of Construction Economics and Building, 12(4).
https://doi.org/10.5130/ajceb.v12i4.3032
Baharetha, S., Soliman, A. M., Hassanain, M. A., Alshibani, A., & Ezz, M. S. (2024). Assessment
of the challenges influencing the adoption of smart building technologies. Frontiers in Built
Environment, 9. https://doi.org/10.3389/fbuil.2023.1334005
Bamgbose, O. A., Ogunbayo, B. F., & Aigbavboa, C. O. (2024). Barriers to Building Information
Modelling Adoption in Small and Medium Enterprises: Nigerian Construction Industry
Perspectives. Buildings, 14(2), 538. https://doi.org/10.3390/buildings14020538
Bateman, A., Buckley, A., Gibbons, J., & Reinhold, M. (2024, April 28). JEP 261: Module
System. Https://Openjdk.Org/Jeps/261.
Black, N. (2018). Nicolai parlog on Java 9 modules. In IEEE Software (Vol. 35, Issue 3).
https://doi.org/10.1109/MS.2018.2141025
Cai, Z., Li, J., & zhang, J. (2020). Research on Performance Optimization of Web Application
System based on JAVA EE. Journal of Physics: Conference Series, 1437(1), 012039.
https://doi.org/10.1088/1742-6596/1437/1/012039
Campbell, T. (2023, August 31). Challenges of legacy system integration: An in-depth analysis.
Https://Www.Torocloud.Com/Blog/Challenges-of-Legacy-System-Integration-an-in-Depth-
Analysis.
Deitel, H., & Deitel, P. J. (2017). Java How to Program, Early Objects, Global Edition. In Java
How to Program, Early Objects, Global Edition.
Deitel, P. (2017, September). Understanding Java 9 Modules.
Https://Www.Oracle.Com/Ng/Corporate/Features/Understanding-Java-9-Modules.Html.
Deitel, P., & Deitel, H. (2018). Java How to Program Early Objects Eleventh Edition (11th ed.).
Pearson Education Limited.

Page 21 of 24
Eadie, R., Odeyinka, H., Browne, M., McKeown, C., & Yohanis, M. (2014). Building
Information Modelling Adoption: An Analysis of the Barriers to Implementation. Journal
of Engineering and Architecture, 2(1), 77–101.
Eastman, C., Teicholz, P., Sacks, R., & Liston, K. (2011). BIM handbook: A Guide to building
Information Modeling for owners, managers, designers, Engineers and contractors (2nd
edition ed.): Wiley Publishing. In John Wiley & Sons, Inc, Hoboken.
Echeverría, A., Cevallos, C., Ortiz-Garces, I., & Andrade, R. O. (2021). Cybersecurity model
based on hardening for secure internet of things implementation. Applied Sciences
(Switzerland), 11(7). https://doi.org/10.3390/app11073260
Fontes, T., Correia, J., de Sousa, J. P., de Sousa, J. F., & Galvão, T. (2017). A Multi-User
Integrated Platform for Supporting the Design and Management of Urban Mobility
Systems. Transportation Research Procedia, 27, 35–42.
https://doi.org/10.1016/j.trpro.2017.12.158
Franklin, C. (2024, January 17). A Guide to Java Modularity. Https://Www.Baeldung.Com/Java-
Modularity.
geeksforgeeks. (2024, January 2). Java Modules. Https://Www.Geeksforgeeks.Org/Java-
Modules/.
Glodon Company Limited. (2022, March 16). 6 Challenges Construction Sector Faces in
Digitalization. Https://Www.Linkedin.Com/Pulse/6-Challenges-Construction-Sector-Faces-
Digitalization-Glodoncompany.
Gupta, L. (2022, October 1). Java Modules Tutorial. Https://Howtodoinjava.Com/Java9/Java-9-
Modules-Tutorial/.
Heiding, F., Katsikeas, S., & Lagerström, R. (2023). Research communities in cyber security
vulnerability assessments: A comprehensive literature review. In Computer Science Review
(Vol. 48). https://doi.org/10.1016/j.cosrev.2023.100551
Jecan, A. (2017). Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications. In
Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications.
https://doi.org/10.1007/978-1-4842-2713-8
Juneau, J. (2017). Java 9 Recipes. In Java 9 Recipes. https://doi.org/10.1007/978-1-4842-1976-8
Leszczyna, R. (2018). A review of standards with cybersecurity requirements for smart grid. In
Computers and Security (Vol. 77). https://doi.org/10.1016/j.cose.2018.03.011
Li, Y., Ou, D., Zhou, X., Jiang, C., & Cérin, C. (2022). Scalability and performance analysis of
BDPS in clouds. Computing, 104(6), 1425–1460. https://doi.org/10.1007/s00607-022-
01056-7
Micheli, G. J., Trucco, P., Sabri, Y., & Mancini, M. (2019). Modularization as a system life cycle
management strategy: Drivers, barriers, mechanisms and impacts. International Journal of
Engineering Business Management, 11, 184797901882504.
https://doi.org/10.1177/1847979018825041
Odubiyi, T. B., Aigbavboa, C. O., & Thwala, W. D. (2019). Information and communication
technology application challenges in the construction industry: A narrative review. IOP

Page 22 of 24
 Conference Series: Materials Science and Engineering, 640(1), 012025.
https://doi.org/10.1088/1757-899X/640/1/012025
Paila, A. (2020). Java Module System - Introduction. Https://Www.Linkedin.Com/Pulse/Java-
Module-System-Introduction-Anjith-Paila.
Papadonikolaki, E., Krystallis, I., & Morgan, B. (2022). Digital Technologies in Built
Environment Projects: Review and Future Directions. Project Management Journal, 53(5),
501–519. https://doi.org/10.1177/87569728211070225
Posa, R. (2022, August 3). Java 9 Modules.
Https://Www.Digitalocean.Com/Community/Tutorials/Java-9-Modules.
Regona, M., Yigitcanlar, T., Xia, B., & Li, R. Y. M. (2022). Opportunities and Adoption
Challenges of AI in the Construction Industry: A PRISMA Review. Journal of Open
Innovation: Technology, Market, and Complexity, 8(1), 45.
https://doi.org/10.3390/joitmc8010045
Sharma, Ms. A., & Saraswat, P. (2021). Review of the Literature on Smart Grid Cybersecurity.
International Journal of Innovative Research in Computer Science & Technology.
https://doi.org/10.55524/ijircst.2021.9.6.56
Shashi, A. (2024, February 11). Mastering Legacy System Integration: A Comprehensive Guide
to Modernizing Your IT Infrastructure. Https://Www.Linkedin.Com/Pulse/Mastering-
Legacy-System-Integration-Comprehensive-Guide-Shashi-H3qhe.
Smith, W. (2024, January 26). Legacy System Integration: Balancing Modernization and
Preservation. Https://Medium.Com/@williamsmth22/.
Solanki, S. D., & Solanki, A. D. (2020). Implementation of big data and machine learning in
smart grid with correlated safety considerations: Review. Proceedings - 2020 IEEE
International Symposium on Sustainable Energy, Signal Processing and Cyber Security,
ISSSC 2020. https://doi.org/10.1109/iSSSC50941.2020.9358879
Stojanov, Z. (2022). SOFTWARE MAINTENANCE MANAGEMENT IN MICRO SOFTWARE
COMPANIES. Southeast European Review of Business and Economics, 3(1), 75–92.
https://doi.org/10.20544/SERBE.05.01.22.P05
Team Azilen. (2024, January 8). From Old to Bold: A Strategic Guide to Legacy System
Integration. Https://Www.Azilen.Com/Blog/Legacy-System-Integration/.
Turk, Z., Bjork, B. C., & Karstilla, K. (1998). Towards a generic process model for AEC.
Congress on Computing in Civil Engineering, Proceedings.
tutorialspoint. (2024). Java - Module System.
Https://Www.Tutorialspoint.Com/Java/Java_module_system.Htm.
Tyson, M. (2020, July 6). What is JPMS? Introducing the Java Platform Module System.
Https://Www.Infoworld.Com/Article/3543253/What-Is-Jpms-Introducing-the-Java-
Platform-Module-System.Html.
Vohra, V. (2023, August 10). The Challenges of Software Development in the Construction
Industry. Https://Www.Rheal.Com/the-Challenges-of-Software-Development-in-the-
Construction-Industry.Html.

Page 23 of 24
Xu, P., Gao, X., & Agee, P. (2022). Management Solutions for Cyber-Physical Security in Smart
Built Environment. Construction Research Congress 2022: Computer Applications,
Automation, and Data Analytics - Selected Papers from Construction Research Congress
2022, 2-B. https://doi.org/10.1061/9780784483961.107

Page 24 of 24