Tasks and Duties
Objective: In this task, you are expected to analyze the requirements provided for a sample C# application and develop a comprehensive system architecture design. You will create a design document that outlines the key components, classes, interfaces, and their interactions. This exercise will help you understand the importance of planning before coding and ensure that you can translate user requirements into a solid architecture.
Task Details: You will design a simple inventory management system using C#. Begin by drafting the system's use cases and functional requirements based on a fictitious scenario provided by you. Identify the major modules such as user authentication, inventory tracking, product management, and reporting. Create UML diagrams including class diagrams, sequence diagrams, and component diagrams which detail the system's structure.
Steps to Complete: First, gather your list of requirements by brainstorming possible features for an inventory system. Next, design a high-level architecture and create detailed diagrams using a tool of your choice (e.g., draw.io, Lucidchart). Compile your analysis, diagrams, and design rationale into a single document. Finally, review your work to ensure it covers all critical components of the system.
Expected Deliverable: A design document in PDF or DOCX format including a detailed requirements analysis, UML diagrams, and architectural outline.
Evaluation Criteria: Your submission will be evaluated on clarity, comprehensiveness, correctness of diagrams, and your ability to justify design decisions.
Objective: In this task, you will develop a CRUD (Create, Read, Update, Delete) console application in C#. The purpose is to demonstrate your ability to write clean, functional, and testable code while interacting with a simple data storage system implemented using in-memory lists or dictionaries.
Task Details: The application will simulate a student management system. It should allow users to add, retrieve, update, and delete student records consisting of student ID, name, age, and course details. This project will require you to implement file-based logging mechanisms and error handling to produce a robust solution.
Steps to Complete: Begin by outlining the structure of your application, including class definitions for student management. Develop each CRUD operation ensuring appropriate validations and error handling. Test all functionalities using sample data inputs. Make sure to comment your code and follow best practices in coding style. Integrate file logging for operations such as record creation or deletion to help in troubleshooting issues during runtime.
Expected Deliverable: A zipped folder containing your complete source code files along with a README file explaining how to run the application and how its functionality meets the task requirements.
Evaluation Criteria: Functionality, code readability, adherence to C# best practices, error handling, and the clarity of the documentation.
Objective: This task emphasizes the significance of software testing. You will write unit tests for a provided C# module and perform debugging activities to analyze and fix issues. The goal is to ensure that your code is reliable and fully covered by tests.
Task Details: You are provided with a self-contained C# module (created by you) that performs specific operations such as mathematical computations or simple data manipulation. Your task is to write a suite of unit tests using a testing framework such as MSTest, NUnit, or xUnit. Additionally, you should simulate edge cases and fix any bugs you discover during the testing phase.
Steps to Complete: Develop or select a self-contained module to work with. Write comprehensive unit tests targeting all possible scenarios including edge cases. Run your tests, observe failing cases, and then debug your code to fix identified issues. Document your debugging process and the rationale behind each fix. Finally, integrate the tests into your development workflow.
Expected Deliverable: A project repository or a zipped folder including the C# module, the corresponding unit test suite, and a detailed report (PDF or DOCX) documenting the debugging process and fixes applied.
Evaluation Criteria: Quality and coverage of tests, effectiveness of debugging, clarity of documentation, and adherence to testing best practices in C# development.
Objective: This task focuses on evaluating and improving the performance of a C# application. You will identify performance bottlenecks in a sample application, optimize the code, and document the improvements in execution speed and resource utilization.
Task Details: Start by selecting or creating a C# application that simulates a moderately complex task, such as handling large datasets or performing intensive calculations. Use profiling tools to identify parts of the code that need optimization. The objective is to refactor the code to make it more efficient, both in terms of speed and memory usage.
Steps to Complete: Run a performance profiling tool (such as Visual Studio Diagnostic Tools) on your application to determine bottlenecks. Identify inefficient algorithms, redundant processes, or poorly managed memory structures. Refactor the code to optimize performance by applying best practices such as using efficient data structures, asynchronous programming, and caching where appropriate. Document before-and-after performance statistics to illustrate improvements. Optionally, include unit tests to ensure that refactoring does not break functionality.
Expected Deliverable: A zipped package that includes the refactored source code, performance profiling reports, and a comprehensive document detailing the optimization process and performance improvements.
Evaluation Criteria: The effectiveness of the optimizations, clarity of the performance analysis, quality of refactored code, and thoroughness of documentation.
Objective: In the final week, you will simulate a mini project that involves integrating multiple modules and setting up a continuous delivery (CD) pipeline. Your task is to demonstrate how individual components developed previously can be integrated into a unified system and deployed using modern CI/CD practices.
Task Details: Develop a small application by integrating separate modules (which can be simple parts such as a login module, data processing module, and reporting module) into one cohesive system. Additionally, create a configuration script for a CI/CD tool (e.g., GitHub Actions, Azure DevOps Pipelines) that automates the building, testing, and deployment of your application.
Steps to Complete: Write or compile separate modules of the application ensuring they all follow consistent coding standards and interface properly with each other. Integrate these modules into a single solution using C# and verify that they work as expected. Next, design and implement a CI/CD pipeline configuration script that automatically builds and runs tests on your integrated solution. Document each step of your integration process and explain how the CI/CD pipeline supports reliable and continuous deployment.
Expected Deliverable: A zipped folder that includes the integrated C# solution, the CI/CD pipeline configuration script, and a detailed document (PDF or DOCX) describing the integration and deployment process, along with any challenges faced and how they were resolved.
Evaluation Criteria: Effectiveness of module integration, proper functioning of the CI/CD pipeline, quality of the deployment configuration, comprehensiveness of documentation, and demonstration of continuous delivery best practices.