Junior Django Developer

Objective: Create a fully functional Django blog application that allows users to view posts, create new posts, and comment on them. The goal is to familiarize yourself with Django project setup, model design, views, templates, and the basics of routing.

Task Overview: In this task, you will set up a Django project from scratch and build a blog application with a clear separation of concerns between your models, views, and templates. You will design data models for blog posts and comments, implement the corresponding views for listing, creating, and viewing details of posts, and create user-friendly HTML templates that display the data dynamically. Ensure proper URL mapping and error handling in your application.

Key Steps:

• Initialize a new Django project and configure your development environment.
• Create a Django app (e.g., "blog") and define models for posts and comments including necessary fields like title, content, author, and publication date.
• Create and apply migrations to set up your database.
• Develop views to handle listing of posts, post detail view, and a form for creating new blog posts.
• Create HTML templates with a clean and responsive design for each view.
• Ensure URL patterns are correctly defined in the urls.py file.

Expected Deliverable: Submit a zipped file of your entire Django project directory along with a README file documenting your project structure, how to run the application, and any design decisions or challenges you encountered.

Evaluation Criteria: Your submission will be evaluated on project structure, code quality, proper use of Django features, functionality, and the clarity of documentation. Extra points will be given for implementing CSS styling and responsive design.

Objective: Enhance a Django web application by integrating user authentication and authorization mechanisms. This task focuses on enabling user sign up, login, logout, and profile management using Django's built-in authentication framework.

Task Overview: In this task, you will extend your Django application to include features that allow users to register, log in, and log out securely. You will implement custom user registration and create forms to validate user input. Additionally, you will create user profile pages that display user-specific information once authenticated. Ensure that page access is controlled so that only authenticated users can see profile details while non-authenticated users are redirected to the login page.

Key Steps:

• Set up Django's built-in authentication system.
• Create registration, login, and logout views using Django forms.
• Develop a user profile view and corresponding template that displays user data.
• Implement necessary URL paths and ensure proper redirection for unauthorized access attempts.
• Test your implementation thoroughly to cover different user scenarios.

Expected Deliverable: Submit a zipped file containing your Django project with the authentication features integrated, along with a README file detailing instructions on how to set up and test the new features, and any potential edge cases handled.

Evaluation Criteria: Your work will be assessed based on security considerations, proper use of Django’s authentication tools, clean and maintainable code, and comprehensive documentation including known issues and benefits of your approach.

Objective: Practice identifying, troubleshooting, and fixing issues in a Django application while also focusing on test-driven development and code refactoring. This task aims to simulate real-world scenarios where quick fixes and long-term maintainability are both critical.

Task Overview: You will be provided with a self-created Django application (or develop one based on previous tasks) that intentionally includes some buggy behavior, inefficient code, or sub-optimal database queries. Your challenge is to review, debug, and refactor the code to enhance performance and maintainability. You will also write unit tests to cover your repaired code. While you do this, focus on adhering to Django best practices and the Clean Code principles.

Key Steps:

• Analyze the provided Django application code to identify common bugs or issues.
• Use Django’s debugging tools and log outputs to isolate issues.
• Refactor code portions to improve readability and performance, ensuring proper query optimization.
• Write unit tests for critical parts of the code using Django’s testing framework to validate that bugs are fixed and functionality is maintained.
• Document the debugging and refactoring process comprehensively in your README file.

Expected Deliverable: Submit the entire Django project folder as a zipped file. This folder should include the refactored code, test files, and a detailed README that explains the bugs found, the steps taken for debugging, refactoring decisions, and instructions to run the tests.

Evaluation Criteria: Submissions will be evaluated based on the effectiveness of bug fixes, the quality and coverage of unit tests, improvement in code efficiency, and clarity of documentation. Extra credit will be given if innovative debugging techniques or design patterns are used.

Objective: Optimize the performance of a Django web application by implementing caching strategies and efficient querying techniques. This task is designed to teach students how to boost the performance and scalability of web applications through code and database query optimizations, as well as leveraging Django’s caching framework.

Task Overview: In this final task, you will work on an existing Django application (this could be a continuation of your previous weeks’ project) and focus solely on performance improvements. You will analyze application components that cause latency and optimize them by implementing Django’s caching solutions such as per-view caching, template fragment caching, or low-level caching. Additionally, you will fine-tune your database queries by using Django ORM optimizations, like select_related and prefetch_related, wherever suitable.

Key Steps:

• Profile the application to identify slow-loading views, inefficient queries, or heavy computations.
• Implement appropriate caching mechanisms using Django’s cache framework. You may use a simple in-memory cache or file-based caching as part of your solution.
• Optimize database queries and ensure that each view retrieves data efficiently.
• Document and compare the performance improvements pre- and post-optimization.
• Include a comprehensive README that explains your optimization approach, any trade-offs considered, and instructions on replicating the performance tests.

Expected Deliverable: Submit a zipped file containing the improved Django project along with a detailed README file that records the performance optimization steps, caching configurations, and instructions on how to test the improved performance.

Evaluation Criteria: Your submission will be assessed on the effective identification of performance bottlenecks, the success of caching implementations, improvements in response time, clarity of the performance documentation, and adherence to best practices. Extra recognition will be provided for innovative or advanced optimization techniques.