Version 1.0.1

[mahmoudElkarargyBS]

💡 Brief

Version 1.0.1 which mainly fix bugs

📋 Task description from last release v1.0.0

• Implemented a new changelog.
• Introduced a benchmarking script.
• Resolved issues with MPI installation.
• Fixed the printing of configuration summaries with MPI.
• Automated the process of adding a new kernel.
• Improved packaging of software with CPack.
• Addressed installation issues.
• Fixed bivariate and trivariate kernel functionality.
• Corrected time-space kernel issues.
• Updated the installation process for dependencies.
• Modified the calculation of P for all kernels.
• Adjusted CMake variables.
• Revised the process of finding BlasPP and Catch2 libraries.
• Updated doxygen documentation.
• Eliminated non-stationary kernel support.
• Removed Find OpenMP, LapackPP, and CuSolver.

🏁 Merge Request Code Quality Checklist

• Code Review: Request a thorough code review from at least one team member.
• Coding Standards: Ensure the code follows the established coding standards and style guide (e.g., Google Style Conventions).
• Naming Conventions: Verify that variable, function, and class names are clear, descriptive, and follow the naming conventions.
• Comments: Check for clear and concise comments explaining the code's purpose, logic, and any complex algorithms or business rules.
• Function/Method Documentation: Ensure that important functions and methods are properly documented using Doxygen or a similar documentation tool.
• Code Formatting: Confirm consistent code formatting, including proper indentation, spacing, and line breaks.
• Error Handling: Check for appropriate error handling and meaningful error messages.
• Testing: Verify that the code has been adequately tested, including unit tests and integration tests, to cover different scenarios and edge cases.
• Test Coverage: Validate that the code has sufficient test coverage, aiming for a high percentage of code coverage.
• Performance: Consider the code's performance implications and identify any potential bottlenecks or optimizations.
• Code Duplication: Look for duplicated code and refactor it into reusable functions or classes.
• Dependencies: Ensure that new dependencies are necessary and properly documented, and that existing dependencies are up to date.
• Memory Management: Check for proper memory allocation and deallocation, avoiding memory leaks and excessive memory usage.
• Thread Safety: Consider thread safety concerns and ensure proper synchronization mechanisms are in place, if applicable.
• Documentation: Update any relevant documentation, including README files, user guides, and API documentation.
• Performance: Consider the code's performance implications and identify any potential bottlenecks or optimizations.
• Integration: Ensure the code integrates smoothly with existing components and systems.
• Build: Verify that the code builds successfully, without errors or warnings, on the target platforms and configurations.
• Code Review Feedback: Address any feedback received during the code review process and make necessary changes.
• Testing: Perform additional testing after incorporating code review feedback.

📝 C++ Best Practices

Please consider the following best practices when working with C++:

• Use Modern C++ Features: Utilize modern C++ features and idioms, such as smart pointers, lambda expressions, range-based loops, and standard library algorithms.
• Follow Coding Standards: Adhere to a consistent coding style and follow established coding standards, such as the Google C++ Style Guide or the C++ Core Guidelines.
• Avoid Using C-Style Constructs: Minimize the use of C-style constructs (e.g., raw pointers, arrays) and prefer safer and more expressive C++ alternatives.
• RAII (Resource Acquisition Is Initialization): Utilize the RAII principle to manage resources automatically through constructors and destructors, ensuring proper resource cleanup.
• Avoid Global Variables: Minimize the use of global variables as they can lead to tight coupling and make code harder to test and maintain. Prefer encapsulation and proper scoping.
• Avoid Magic Numbers: Replace magic numbers with named constants or enums to improve code readability and maintainability.
• Use Meaningful Names: Choose descriptive and meaningful names for variables, functions, classes, and other identifiers to enhance code understandability.
• Avoid Code Duplication: Refactor duplicated code into reusable functions or classes to promote code reuse and reduce maintenance efforts.
• Error Handling: Use appropriate error handling mechanisms, such as exceptions or error codes, to handle and propagate errors consistently throughout the codebase.
• Unit Testing: Write comprehensive unit tests to validate the correctness of individual components and ensure proper code coverage.
• Avoid Undefined Behavior: Be aware of undefined behavior in C++ and avoid writing code that produces undefined or unspecified results.
• Memory Management: Use appropriate memory management techniques, such as smart pointers or containers, to avoid memory leaks and dangling pointers.
• Const-Correctness: Utilize const and constexpr to enforce immutability and prevent unintended modifications to variables and parameters.
• Keep Code Simple: Strive for simplicity in code design and implementation, favoring clear and maintainable solutions over unnecessarily complex ones.

These best practices aim to enhance code readability, maintainability, and reliability while following industry-standard guidelines and principles.

⬇️ Installation

Please follow up on the README.md and USER_MANUAL.md for the installation, It will be a great test to check the readability of the README and to rate how easy you can download our software

©️ Copyrights

Developer: @mahmoud.elkarargy

Reviewers: @omar.marzouk and @merna.moawad.

Copyright (c) 2017-2023 King Abdullah University of Science and Technology,

Copyright (C) 2021-2023 by Brightskies Inc.

All rights reserved.