dayendar

Repository on GitHub, which provides public git repositories with URLs.

Repository on GitHub, which uses git. git can track the changes, who made them, and when they were made.

Repository on GitHub, which uses git. git is distributed.

We use semantic versioning to tag our releases. Additionally, we include the commit identifier: https://github.com/racherb/dayendar/releases/

Issue Tracker through GitHub

By using GitHub's Issue Tracker, we ensure that every bug report or issue submitted is logged, timestamped, and available for review by the development team. GitHub's notification system ensures that the repository maintainers and contributors are informed of new issues when they are created. This facilitates timely acknowledgment. Furthermore, GitHub provides features like comments, reactions (e.g., thumbs up, thumbs down), and labels. These can be used to acknowledge bug reports. Even if a fix is not immediately available, team members can comment on the issue to acknowledge its receipt, provide interim solutions, or request further information. This ensures open communication with the reporter and demonstrates that the project is actively monitored and maintained. Thus, by utilizing the features and notifications of GitHub's Issue Tracker, we can efficiently acknowledge and respond to the majority of bug reports within the specified timefram

Using GitHub's Issue Tracker, we have a centralized system to monitor, label, and categorize enhancement requests. With the labeling feature, we can specifically tag issues as "enhancements" and ensure they are addressed. The platform's built-in notification and commenting system ensures that maintainers are informed and can respond, even if the response is a simple acknowledgment, discussion, or a 'no'. By actively engaging with these enhancement requests, we demonstrate that the project remains active and responsive to user feedback.

By hosting our project on GitHub, every issue (which includes bug reports, enhancement requests, etc.) and its associated responses are inherently archived and publicly accessible. GitHub's Issue Tracker provides a history of all interactions, ensuring transparency and availability for later review or searching: https://github.com/racherb/dayendar/issues

Through gitHub Action. Currently there are two workflows. One of them compiles the code and runs the automated unit tests.

Cargo, Rust's standard package manager and build system, is used to build software. Cargo is widely recognised and used in the Rust community for dependency management, build, testing and other tasks related to the software development lifecycle. Instructions for building the project using Cargo are available in our README.md file at https://github.com/racherb/dayendar/blob/dev/README.md.

The project uses Rust and Cargo for building and dependency management, both are open source tools distributed under MIT/Apache-2.0 licenses. All dependencies and additional tools used in the project are FLOSS, ensuring that the project is buildable using only free and open source software tools.

The project uses the Rust integrated test system to implement automated tests. These tests are included in the public repository and can be run using cargo test. The tests and the project code are released under the Apache-2.0 licence and are fully FLOSS. Instructions for running the tests are documented in our CONTRIBUTING.md file https://github.com/racherb/dayendar/blob/dev/CONTRIBUTING.md, as appropriate). In addition, we have configured GitHub Actions to automatically run these tests on every commit, ensuring the quality and functionality of the code.

Executing "cargo test"

The project uses the rustc compiler which, by default, triggers a number of warnings to ensure code quality and prevent common bugs. In addition, we use Clippy, a Rust-specific linting tool, which provides additional suggestions and warnings to improve code quality and readability. Instructions on how to use these tools are documented in our CONTRIBUTING.md file.

The project actively monitors and addresses warnings generated by the rustc compiler and the Clippy linting tool. We strive to maintain high quality code and fix all relevant warnings. In cases where we consider a warning to be a false positive, we flag it and document it in the source code.

The Rust project follows a policy of being as strict as possible with warnings and bugs. We use the rustc compiler and Clippy linting tool with strict settings to detect and correct problems in the early stages of development. In addition, our continuous integration (CI) ensures that any new code meets these strict standards. Our policy and practices regarding warnings are clearly documented in our CONTRIBUTING.md file.

Rust inherently emphasizes safety through its type system and ownership properties. To meet the above requirement, beyond the compiler's assurances: Clippy: A linting tool for Rust, it detects common errors, suggests improvements, and ensures adherence to Rust's best practices. While Rustc has its built-in linter, Clippy provides more detailed, specific checks. Cargo-audit: This tool checks Rust project dependencies for known vulnerabilities, referencing the RustSec Advisory Database. Before a major production release, running Clippy ensures lint-free code, and Cargo-audit verifies the absence of known vulnerable dependencies. By using these tools, we leverage both Rust's built-in security capabilities and additional open-source tools to ensure software quality and safety.

For Rust projects, while the language's design inherently mitigates many common vulnerabilities, we can still employ tools that further scrutinize the codebase for potential issues: Clippy: Beyond linting for code quality, some of Clippy's lints can indirectly identify code patterns that might lead to vulnerabilities, especially when they deviate from Rust's idiomatic practices. Cargo-audit: Directly addresses the criterion's suggestion. It scans the project's dependencies for known security vulnerabilities, ensuring that the software doesn't inadvertently include libraries with recognized vulnerabilities. By integrating both Clippy and Cargo-audit into the development workflow, we not only uphold Rust's safety principles but also actively scan for common vulnerabilities, aligning with the requirement's intent.

Static analysis through "cargo clippy" and "cargo audit" are automated through GitHub Actions flows.

For dynamic code analysis we are enabling the use of "cargo fuzzy".

In our project we use the Rust programming language which is characterised by memory safety, however, we apply fuzzing techniques through "cargo fuzz".