Project Grading Criteria: A Detailed Breakdown

This document provides a comprehensive overview of the grading criteria for this project, drawing inspiration from the guidelines provided by heig-vd-dai-course. It aims to offer clarity and ensure a transparent evaluation process. Understanding these criteria is crucial for achieving success in this project. We will explore each category in detail, outlining the expectations and requirements.

Category 1: Git, GitHub, and Markdown

This category emphasizes the importance of effective documentation and collaboration using Git, GitHub, and Markdown. A well-structured README file serves as the gateway to your project, providing essential information for users and contributors alike. The goal here is to demonstrate your ability to communicate the project's purpose, functionality, and setup process clearly and concisely. Think of your README as the first impression – it should be inviting, informative, and easy to navigate. A strong README not only showcases your project but also reflects your understanding of best practices in software development. To excel in this category, your README should go beyond basic descriptions and delve into the core functionalities of your application, explaining how different components interact and contribute to the overall user experience. Furthermore, incorporating visual aids such as diagrams or screenshots can significantly enhance understanding and engagement. Remember, the clarity and completeness of your documentation directly impact how easily others can understand and contribute to your project.

The primary focus of this section lies in a well-structured README file. Your README should clearly articulate the project's purpose and include the names of the authors. This ensures that new users can quickly grasp the project's intent and identify the individuals responsible for its development. A well-crafted README is essential for project discoverability and user engagement. It's not just about technical specifications; it's about making your project accessible and understandable to a broad audience. Consider the README as the welcome mat for your project – it should be inviting and informative, encouraging users to explore further. By providing a clear and concise overview, you empower others to engage with your work effectively. The inclusion of author names adds a personal touch and provides a point of contact for inquiries or collaborations. This element of transparency fosters trust and encourages a collaborative spirit within the community.

Category 2: Java, IntelliJ IDEA, and Maven

This section assesses your proficiency in using Java, IntelliJ IDEA, and Maven for building and managing your project. It emphasizes the importance of providing clear instructions for setting up and running the application, as well as maintaining a well-structured and documented codebase. A clean and organized codebase is not just about aesthetics; it's about maintainability and scalability. It allows other developers to quickly understand the project's architecture, identify potential issues, and contribute effectively. Demonstrating a strong grasp of these tools and practices is crucial for building robust and maintainable software. The ability to write clean, well-documented code is a hallmark of a skilled developer, and this category aims to evaluate your capabilities in this area. Furthermore, providing explicit instructions for cloning and building the application ensures that others can easily replicate your development environment and contribute to the project. This fosters collaboration and accelerates the development process.

This category emphasizes the importance of providing explicit commands in your README for cloning and building the network application using Git and Maven. This enables new developers to quickly set up the project on their own computers and begin contributing. Clear, step-by-step instructions are crucial for fostering collaboration and ensuring that others can easily replicate your development environment. Think of these commands as the keys to your project – they unlock the ability for others to explore, modify, and enhance your work. By providing a seamless setup process, you lower the barrier to entry and encourage wider participation. This not only benefits your project directly but also contributes to a more collaborative and inclusive development community. Remember, the easier it is for others to get started, the more likely they are to contribute and help your project thrive.

Additionally, your codebase should be well-structured, easy to access, easy to understand, and thoroughly documented. This ensures that newcomers can quickly grasp the project's architecture and functionality. A well-organized codebase is like a well-organized workshop – it allows you to find the tools you need quickly and efficiently. Similarly, clear documentation acts as a guide, helping others navigate the codebase and understand its inner workings. By investing in code structure and documentation, you're not only making your project more accessible but also future-proofing it against potential issues and ensuring its long-term maintainability. This category underscores the importance of these practices in building scalable and collaborative software projects.

Category 3: Docker and Docker Compose

This category focuses on containerization using Docker and Docker Compose, which are essential tools for modern application deployment. Containerization allows you to package your application and its dependencies into a single unit, ensuring consistent behavior across different environments. This is particularly crucial for web applications, which often need to be deployed on various servers and platforms. Docker simplifies the deployment process and eliminates many of the compatibility issues that can arise when deploying applications manually. Furthermore, Docker Compose allows you to define and manage multi-container applications, making it easier to orchestrate complex deployments. Mastering these tools is essential for any developer working on web applications, and this category evaluates your ability to effectively utilize them.

Your network application should be packaged and published to GitHub Container Registry using Docker. This allows others to easily use your application with Docker, regardless of their local environment. Publishing your application as a Docker image makes it readily accessible and ensures consistency across different deployments. Think of it as creating a self-contained package that can be easily distributed and run anywhere. This streamlines the deployment process and eliminates many of the compatibility issues that can arise from differing environments. By leveraging GitHub Container Registry, you can make your application available to a wider audience and encourage collaboration. This category emphasizes the importance of containerization in modern software development and its role in simplifying deployment and ensuring consistency.

The README should include explicit commands for building and publishing your network application with Docker. This ensures that others can easily reproduce your Docker build process and contribute to the project. Clear and concise instructions are crucial for reproducibility and collaboration. By providing explicit commands, you empower others to build and publish your application, fostering a sense of shared ownership and responsibility. This not only benefits your project directly but also contributes to the overall health of the open-source community. The ability to reproduce a build is a cornerstone of software development, and this category highlights the importance of documenting the process thoroughly.

Furthermore, the README should include explicit commands for using your network application with Docker Compose. Docker Compose simplifies the process of defining and managing multi-container applications, making it an essential tool for modern deployments. Clear instructions for using Docker Compose allow others to easily run your application and its dependencies, streamlining the setup process and reducing the likelihood of errors. Think of Docker Compose as a recipe for your application – it outlines the steps needed to bring all the ingredients together and create a working system. By providing explicit commands, you make it easy for others to follow that recipe and get your application up and running quickly. This category underscores the importance of Docker Compose in simplifying complex deployments and fostering collaboration.

The Docker applications (Traefik and your web application) should be split into multiple directories and make usage of networks to communicate together. This promotes modularity and ensures that the applications are properly isolated from each other. Separating your applications into multiple directories helps to keep your project organized and maintainable. It also allows you to manage each application independently, making it easier to update or modify specific components without affecting others. Using Docker networks to facilitate communication between applications ensures that they can interact seamlessly while maintaining a secure and isolated environment. This category highlights the importance of architectural design in Docker deployments and its impact on scalability and maintainability.

Category 4: Java Network Concurrency

This category delves into the crucial aspect of handling concurrent access to data structures within your network application. Concurrency is a fundamental challenge in multi-threaded environments, and ensuring data integrity in the face of simultaneous access is paramount. The data structures used in the network application must be resilient to concurrent accesses. This often involves employing synchronization mechanisms such as locks or atomic operations to prevent race conditions and data corruption. A deep understanding of concurrency principles is essential for building robust and reliable network applications. This category evaluates your ability to design and implement thread-safe data structures that can withstand the demands of a concurrent environment. Failing to address concurrency issues can lead to unpredictable behavior and data loss, making this category a critical assessment of your software engineering skills.

The key focus here is that the data structures used in your network application are resilient to concurrent accesses. This means that your application should be able to handle multiple requests simultaneously without compromising data integrity. Concurrent access can lead to race conditions and other issues if not handled properly. Techniques like using synchronized collections or implementing custom locking mechanisms are crucial for achieving thread safety. This category highlights the importance of considering concurrency from the design phase and implementing appropriate safeguards to ensure the stability and reliability of your application.

Category 5: SSH and SCP

This category evaluates your understanding and implementation of secure remote access using SSH and SCP. SSH (Secure Shell) is a cryptographic network protocol that allows you to securely access and manage remote servers. SCP (Secure Copy) is a protocol that enables secure file transfer between computers. These tools are essential for system administration and deployment tasks, as they provide a secure way to interact with remote systems. The expectation here is that you and the teaching staff can access the virtual machine without a password using an SSH key. Passwordless authentication using SSH keys is a security best practice, as it eliminates the risk of password-based attacks. This category assesses your ability to configure and utilize SSH for secure remote access, a fundamental skill for any developer or system administrator.

This category mandates that both you and the teaching staff should be able to access the virtual machine without requiring a password, utilizing an SSH key. Implementing SSH key-based authentication significantly enhances security by removing the vulnerabilities associated with password-based logins. An SSH key pair consists of a private key, which is kept secret on your local machine, and a public key, which is placed on the server you want to access. When you connect to the server, SSH uses cryptographic algorithms to verify your identity based on the key pair, rather than requiring a password. This method not only strengthens security but also streamlines the login process. This category underscores the importance of adopting secure practices in system administration and highlights the role of SSH keys in achieving robust authentication.

Category 6: HTTP and curl

This category delves into your understanding and implementation of HTTP (Hypertext Transfer Protocol) and your ability to interact with your web application using curl. HTTP is the foundation of data communication on the web, and a thorough grasp of its methods, status codes, and resources is essential for building web applications. The curl command-line tool is a versatile utility for making HTTP requests, allowing you to test and interact with web services directly from the terminal. The goal here is to demonstrate your ability to design a RESTful API, implement standard HTTP methods, and provide clear instructions on how to interact with your application using curl. A well-designed API and clear documentation are crucial for enabling others to use and integrate with your application. This category assesses your ability to apply HTTP principles in practice and effectively communicate your API to others.

The README (or repository) should contain the application protocol interface (API) that describes the web application. This API documentation should clearly outline the available endpoints, the HTTP methods they support, the request parameters they accept, and the response formats they return. A well-documented API is crucial for enabling others to use and integrate with your application. Think of the API documentation as a contract between your application and its users – it specifies how they can interact with your service and what they can expect in return. By providing comprehensive API documentation, you lower the barrier to entry for developers and encourage wider adoption of your application. This category highlights the importance of API design and documentation in building successful web services.

Your web application should make use of at least the following HTTP methods: GET, POST, PATCH/PUT, and DELETE. These methods represent the fundamental operations of CRUD (Create, Read, Update, Delete), and their proper implementation is essential for building RESTful APIs. GET is used to retrieve data, POST is used to create new data, PATCH or PUT are used to update existing data, and DELETE is used to remove data. The choice between PATCH and PUT depends on whether you are updating a portion of a resource (PATCH) or replacing the entire resource (PUT). This category assesses your understanding of HTTP methods and their application in building web services. The correct usage of HTTP methods ensures that your API is intuitive and follows industry best practices.

The web application's return status codes must be consistent and reflect the HTTP methods used. HTTP status codes provide feedback to the client about the outcome of the request. For example, a successful GET request might return a 200 OK status, while a failed POST request might return a 400 Bad Request or a 500 Internal Server Error. Using status codes correctly allows clients to understand the result of their requests and handle errors appropriately. Consistent use of status codes is crucial for building reliable and predictable APIs. This category highlights the importance of adhering to HTTP standards and using status codes to communicate effectively with clients.

The web application should offer at least two resources (= domains) on which to operate CRUD operations. This demonstrates your ability to design and implement a multi-resource API. Each resource represents a distinct entity or concept within your application, such as users or products. Providing CRUD operations for multiple resources allows clients to interact with your application in a variety of ways and perform a range of tasks. This category assesses your ability to design APIs that are flexible and can support a diverse set of use cases. A well-designed API should offer a clear and intuitive way to manage multiple resources.

The README should explain how to use your web application with explicit examples using curl with outputs to demonstrate how to interact with your web application deployed on the Internet. curl is a powerful command-line tool for making HTTP requests, and providing examples of its usage allows others to quickly test and interact with your API. Including the outputs of the curl commands demonstrates the expected responses and helps users understand how to interpret the results. This category emphasizes the importance of providing practical examples and clear instructions for using your API. By showing users how to interact with your application, you lower the barrier to entry and encourage wider adoption.

Category 7: Web Infrastructures

This category focuses on the infrastructure aspects of deploying and running your web application, encompassing topics such as virtual machine setup, DNS configuration, and deployment using Docker Compose. A solid understanding of web infrastructure is crucial for ensuring that your application is accessible, scalable, and reliable. This category assesses your ability to configure a virtual machine, set up DNS records to map domain names to your application, and deploy your application using Docker Compose for easy management and scaling. It also emphasizes the use of Traefik as a reverse proxy and load balancer, as well as the implementation of automatic HTTPS/TLS certificate generation using Let's Encrypt. Mastering these concepts and tools is essential for anyone deploying web applications in a production environment.

The README (or repository) should contain instructions on how to install and configure the virtual machine with each step. Clear and detailed instructions are crucial for ensuring that others can replicate your setup and deploy your application successfully. This includes specifying the operating system, the required software packages, and any necessary configuration settings. Providing a step-by-step guide minimizes the chances of errors and makes the deployment process more accessible to others. This category highlights the importance of documenting the infrastructure setup process and ensuring that it is reproducible.

The README (or repository) should contain explanations on how to configure the DNS zone to access your web application. DNS (Domain Name System) is a hierarchical system that translates domain names into IP addresses, allowing users to access your application using a human-readable name. Configuring the DNS zone correctly is essential for making your application accessible on the Internet. This includes creating A records to map your domain name to the IP address of your virtual machine, as well as any necessary CNAME records for subdomains. This category assesses your understanding of DNS and your ability to configure it correctly for your application.

The README (or repository) should contain instructions on how to deploy, run, and access the web applications with Docker Compose. Docker Compose simplifies the process of defining and managing multi-container applications, making it an essential tool for modern deployments. Providing clear instructions on how to use Docker Compose to deploy your application ensures that others can easily run your application and its dependencies. This includes specifying the Docker Compose file, the necessary environment variables, and the commands for starting and stopping the application. This category highlights the importance of Docker Compose in simplifying deployment and making it more reproducible.

At least Traefik and your web application should be deployed on the virtual machine. Traefik is a modern reverse proxy and load balancer that makes it easy to manage traffic to your application. Deploying Traefik in front of your web application provides several benefits, including automatic HTTPS/TLS certificate generation, load balancing, and request routing. This category assesses your ability to use Traefik to manage traffic to your application and ensure that it is accessible and secure.

The README should display the domain names configuration in the DNS zone to validate everything is set up right. This provides a clear and verifiable record of your DNS configuration, allowing others to confirm that your application is properly configured. This includes showing the A records and CNAME records that you have created in your DNS zone. This category emphasizes the importance of documenting your DNS configuration and making it easily accessible for verification.

The web applications (the Traefik dashboard and your own application) should be accessible using a domain name and/or subdomain names. This ensures that your application is accessible to users on the Internet using a human-readable address. Using domain names or subdomains makes it easier for users to remember and access your application. This category assesses your ability to configure your DNS and web server to make your application accessible using domain names.

The web applications (the Traefik dashboard and your own application) should use automatic HTTPS/TLS certificate generations with Let's Encrypt. HTTPS (Hypertext Transfer Protocol Secure) is the secure version of HTTP, and it is essential for protecting the privacy and security of your users. Let's Encrypt is a free, automated, and open certificate authority that makes it easy to obtain and install SSL/TLS certificates. Using Let's Encrypt to generate certificates automatically ensures that your application is always using the latest security standards. This category highlights the importance of security in web application deployment and assesses your ability to implement HTTPS using Let's Encrypt.

Category 8: Caching and Performance

This category assesses your implementation of caching mechanisms to improve the performance of your web application. Caching is a technique used to store frequently accessed data in a temporary storage location, such as memory or a dedicated cache server, so that it can be retrieved more quickly in the future. This can significantly reduce the load on your database and improve the response time of your application. This category requires that requests are cached to improve performance until the data changes. This means that your application should implement a caching strategy that invalidates the cache when the underlying data is modified. A well-implemented caching strategy can dramatically improve the performance and scalability of your web application. This category evaluates your understanding of caching principles and your ability to apply them effectively.

The primary focus of this category is ensuring that requests are cached to improve performance until the data changes. Caching can significantly reduce the load on your server and improve response times for users. Implementing a caching mechanism involves storing frequently accessed data in a temporary location, such as memory or a dedicated cache server, so that it can be retrieved quickly without querying the database or performing other expensive operations. However, it's crucial to invalidate the cache whenever the underlying data is updated to ensure that users always receive the most current information. This category underscores the importance of caching in building high-performance web applications and highlights the need for a robust invalidation strategy.

In conclusion, these grading criteria provide a comprehensive framework for evaluating your project. By understanding and addressing each category, you can ensure that your project meets the required standards and achieves its goals. For further information on best practices for software development and web application deployment, consider exploring resources like MDN Web Docs. Good luck!