Digital Ocean's Command Line Primer is a great intro to using your terminal. It says it's for Linux but it's applicable for Macs, and Windows if you're using something like WSL or Git Bash.
Try to practice using your Terminal to navigate your computer as you're working on other tasks.
GitHub's Markdown introduction introduces using the Markdown language to quickly write simple HTML. Practice your Markdown by writing README.md files for your GitHub repositories. Try to include some headings, lists, images, and maybe even a table.
Execute Program is an interactive code learning platform. Their JS Arrays course is a great recap of things you might have already come across, and should also have some interesting new things.
You should be able to get started with a free account—we can get you paid access later when this runs out.
Your project this week is to build a frontend for one of the APIs from REST API week. It should be a single-page app rendered with client-side JavaScript.
If your team don't have a finished API, or don't want to use it, you can use the Dogs API from the workshops. The readme contains documentation of all the endpoints.
User stories
Core
As a user, I want to: see all the resources
As a user, I want to: sign up for an account
As a user, I want to: log in to my account
Stretch
As a user, I want to: update my own resources
As a user, I want to: delete my own resources
Since this project is open-ended you'll need to write your own more specific user stories once you know what you want to build.
Acceptance Criteria
Stretch criteria
spikes
ES Modules
How can we modularise our client-side JavaScript?
Questions to consider
As a user, I want to: add my own resources
Form for adding new resources (only for logged in users)
What are the different ways we can import/export code? What does "dynamic import" do?
Why might using hundreds of small modules in the browser cause performance problems?
This is a guide to what you should be doing for homework each week. Please reach out to your CFs if you are unsure of what to prioritise between sessions.
Complete the Git, CSS, Semantic HTML, Accessibility and HTML forms workshops ahead of Week 1
Complete the Asynchronous JS, Promises & fetch, Real-world fetch and Promise practice workshops ahead of Week 2
Complete your user manual
Complete your Week01 progress log
Complete github profiles
Project work
Create a presentation on HackMD
Week of September 9th
This week is focused on the fundamental building blocks of web pages—accessible, semantic HTML, and well-organised CSS.
Workshops
To be completed AHEAD of Week01
schedule
Homework
This is a guide to what you should be doing for homework each week. Please reach out to your CFs if you are unsure of what to prioritise between sessions.
Project Setup with Libraries: As a back-end developer, I want to set up a new Node.js project in VS Code with the discord.js and openai libraries using require('discord.js') and require('openai') after installing them with npm, so I can start building my bot with all necessary functionalities.
Secure Configuration
Stretch user stories:
Messaging Users Directly:
Hint: Utilise the user.send() method in Discord.js to send direct messages to users. Retrieve the user object through events or commands that the bot receives.
Dialogue Boxes and Interactive Responses:
Hint: Implement Discord's message components like buttons and select menus using
2. You are going to integrate testing into your Discord chatBot project.
The following user stories are designed to guide you as you integrate testing into your Discord chatBot project. If there are some which are not appropriate to your project, you do not have to integrate these. You can create your own tests that are relevant to your project.
Possible user stories:
As a back-end developer, I want to...
verify Discord.js integration by creating a test function that creates a new Discord client
ensure that the OpenAI library is correctly integrated by creating a test function that attempts to use the OpenAI API to create a simple chat completion or query
test that my bot securely loads API keys from the .env file, confirming that no sensitive information is hard-coded
Repository naming convention
Please name your repo following this template: PRO02_Name1_Name2_Name3_Name4
: As a back-end developer, I want to configure my bot securely by using
require('dotenv/config')
to load my API keys from a
.env
file, ensuring they are not hard-coded into my project, using a
.gitignore
file.
Bot Initialisation: As a back-end developer, I want to initialise my Discord bot and log in to Discord using the new Discord.Client() constructor and client.login method with my Discord token, to start listening for messages.
Message Handling: As a back-end developer, I want to handle incoming messages by setting up a message event listener using client.on('messageCreate', callback) to process messages received in Discord and respond to them with a “hello” message.
Optimisation: As a developer, I want the bot to optimise its performance by efficiently handling events, so that it does not consume excessive resources. This may involve writing efficient callback functions for client.on and client.once, ensuring they execute tasks quickly and without unnecessary resource consumption.
OpenAI Chat Integration and Response Generation: As a back-end developer, I want to integrate OpenAI into my bot and send chat prompts to the API to generate responses. This would involve using the openai.chat.completions.create() method with my OpenAI API key. I aim to pass conversation history and other necessary parameters to this method to receive context-aware chat completions. This will enable the bot to generate dynamic, intelligent responses based on ongoing conversations, enhancing user interaction and experience.
Response Management: As a back-end developer, I want to manage the OpenAI response returned by openai.chat.completions.create() using either fetch or async/await and sending the response back to the Discord channel.
Command Processing: As a back-end developer, I want to process commands directed at my bot by using string matching or a command prefix to distinguish between general messages and commands meant for the bot.
Error Handling: As a back-end developer, I want to implement error handling in my bot interactions using either .catch or try...catch within my fetch or **** async functions to manage exceptions and provide error messages if something goes wrong.
MessageActionRow
and
MessageButton
or
MessageSelectMenu
classes from Discord.js. Handle interactions with
client.on(Events.InteractionCreate, callback)
.
Creating Private Chats (Channels):
Hint: Use guild.channels.create() to create new private channels and manage access using permission overwrites in Discord.js.
Automated Moderation Features:
Hint: Monitor messages for specific keywords or patterns using client.on(Events.MessageCreate, callback). Implement moderation actions like message.delete() for removing inappropriate content and guildMember.timeout() for muting users.
Multimedia Responses (Images, GIFs, Audio Clips):
Hint: Send multimedia content using message.channel.send() with the files option. For audio, explore Discord.js voice modules for handling voice channels and streaming.
ensure that my bot initialises and logs into Discord successfully
simulate receiving a message and verify that my bot responds with a "hello" message, testing the message event listener's functionality
simulate commands directed at my bot to check if it accurately processes these commands from general messages
introduce faults or exceptions in bot interactions to verify that my bot's error handling mechanisms effectively manage and log errors
mock the process of sending responses back to the Discord channel, verifying that my bot formats and dispatches messages correctly
ensure my bot can send direct messages to users, testing the user.send() method's functionality
test my bot's ability to send multimedia responses under specified conditions, ensuring it can handle images, GIFs, and audio clips effectively
A comic explaining what happens when you type a URL into your browser.
Describes the HTTP protocol in a lot more detail. May be useful if you like learning exactly how stuff works under-the-hood, but may also be overwhelming.
How functions and callbacks work in JavaScript. Based on a workshop from this week's curriculum.
Good testing practices so you can be confident your tests are working.
A comparison of creating DOM elements manually versus using the <template> element. Useful technique if you're dynamically rendering lots of stuff with JS.
Learning Outcomes
TypeScript and Express
RESTFUL Api's
Additional
Week of September 23th
Learn how to create a Discord chatbot using Node.js, integrate it with OpenAI's API, and implement testing for your bot.
Your project is to build the backend for a dynamic web application that combines a quiz generator with data from multiple external APIs. This backend will serve as the foundation for a future full-stack application, showcasing your skills in server-side development, API integration, and data manipulation.
Core Requirements
TypeScript Implementation::
The entire backend project must be written in TypeScript.
Utilize TypeScript's static typing for all modules, functions, and API interfaces.
Stretch Goals
Implement more complex quiz generation algorithms (e.g., adaptive difficulty).
Add a favourite count feature for questions and allow filtering by this criterion.
Develop more sophisticated results analysis.
Project Phases
Initial Spike Stage
Set up the basic structure of your Express server.
Implement a single endpoint that interacts with one external API.
Core Project Development
Develop the full set of RESTful endpoints for quiz operations.
Integrate multiple external APIs.
Implement the quiz generation and results calculation logic.
API Suggestions
Easier APIs
Open AI API - https://platform.openai.com/
JokeAPI - https://jokeapi.dev/
The Dog API - https://thedogapi.com/
The Cat API - https://thecatapi.com/
More Challenging APIs
Twitter API - https://developer.twitter.com/en/docs/twitter-api
Google Maps API - https://developers.google.com/maps
Spotify API - https://developer.spotify.com/documentation/web-api/
Submission Guidelines
Host your code in a Git repository with clear documentation.
Deploy your project on GitHub Pages. Feel free to deploy it elsewhere as well if you prefer and have the time.
Include a comprehensive README.md file detailing:
Additional Considerations
Design your API with future frontend integration in mind. The frontend part of this project will be added next week.
Implement proper error handling and validation for incoming requests and external API responses.
Securely store any API keys or sensitive information required by your server.
By completing this project, you will demonstrate your ability to create a robust backend application that combines original functionality with external data sources, showcasing your skills in API development, integration, and server-side logic implementation.
Repository naming convention
Please name your repo following this template: PRO03_BACK_Name1_Name2_Name3_Name4
resources
Typescript
Devtools
Express and RESTFUL APIs
A guide on setting up the tools for this weeks project. Good explanation on generating and modifying a TS config file
resources
React
A framework agnostic tool that allows for quick setup of a React app with TS
Official React docs on typescript with interactive examples
A quick reference guide to basic React patterns
A more guided resource of this material
A powerful hook for passing state values in your application without prop drilling
Figma
Basic exercises for beginners
Testing and deployment
Testing
Deployment
Week of September 30th
This week focuses on building a front-end application using React and TypeScript to consume the RESTful API developed in the previous week. The emphasis is on creating an intuitive user interface for the quiz application while applying React best practices and TypeScript integration.
This week concentrates on testing and deploying the full-stack quiz application developed over the past two weeks. The focus is on implementing comprehensive testing strategies and successfully deploying both the frontend and backend components of the application.
Unit testing backend functionality with Node's built-in testing suite
API testing with Postman
End-to-end testing with Cypress for React applications
Stretches
Implementing Continuous Integration and Deployment (CI/CD) pipelines
Securing applications with HTTPS
Project
Develop a comprehensive testing strategy covering unit, integration, and end-to-end tests
Implement tests using Cypress, Postman, and Node's testing library
Deploy both the backend and frontend
Additional Skills
Managing test data and state
Implementing reverse proxies
Configuring CORS policies
Using GitHub Actions for CI/CD
project
Your task this week is to deploy and test the quiz app you have completed in the previous two weeks.
Description
Before you start you need to create a testing and deployment plan. We would like you plan a testing strategy that will have broad coverage of your project. The tools we would like you to use to achieve this can include Cypress, Postman and the Node built in testing library.
We would like you to deploy both the backend and frontend of your project. Before choosing a deployment platform, consider whether your application is static or dynamic, as this will influence your choice. Here are some options to consider:
AWS EC2 Instance
AWS Lambda (for serverless applications)
Heroku (easy deployment for various application types)
GitHub Pages
AWS S3 Bucket (suitable for static websites)
Vercel
Netlify
Firebase Hosting (suitable for static and dynamic sites)
...
Research these options and choose the ones that best fit your project's needs, considering factors like scalability, ease of use, and cost. Remember, the goal is to understand the deployment process and the considerations involved in choosing a hosting solution.
Questions to consider
What parts of the application logic are the most critical to cover with unit tests?
How will you mock external dependencies (like databases or APIs) during unit testing?
What are the key user journeys and flows within the application that must be covered by end-to-end tests?
Acceptance Criteria
Stretch criteria
resources
Cypress
A good start in understanding component testing
Your one stop shop for example with cypress React
More generic cheat sheet for Cypress
Testing
Official Cypress docs. You'll find some great tutorials to get start there
DevOps
A step by step guide to deploying an express server using the AWS console and SSH
UI for Quizzer App
Your project this week is to build the front end to consume the RESTful API you designed and built last week. You should think and plan what features and look you want to your quiz app to have. You might considered making some wire frames or a prototype using a tool like .
User Stories
As a quizzer, I want to:
Week of October 14th
This week focuses on building a dynamic e-commerce web application, integrating React for the frontend with a Node.js/Express backend and SQLite database. The emphasis is on creating a full-stack application with database integration and state management in React.
Workshops
project
Your project this week is TBC
Intro
Learners will develop an end-to-end dynamic e-commerce web application where users can browse and purchase products online.
The frontend of this project will be built using React. For the backend, it will use Node.js and Express to handle server-side functionality. User accounts and product data will be stored in a SQLite database.
How will you manage test data and state for end-to-end testing?
How will encrypted communication (HTTPS) be set up, and will you use a reverse proxy?
How will you manage configuration variables for different environments (development, staging, production)?
How will CORS policies be configured between the frontend on GitHub Pages and the backend on EC2?
Implementing search functionality in both frontend and backend
Error handling and data validation in full-stack applications
Project
Your project for the next week will be to develop a Express backend connected to a SQLite database and linked to a React frontend. Your UI should provide methods so that users can search for and display information about items and add them to a shopping cart. It is up to you to determine the process and order you take to achieve this, but should plan this carefully and attempt to anticipate any hurdles you approach will encounter.
Spike
Before you start writing features you need to design the schema for your data. Think about what different things your app needs to store, how they relate to each other, and how you can avoid duplicating information. Record your schema in your README.md using Markdown tables. Consider embedding a diagram to help visualise the relationships.
Questions to consider
What kinds of data relationships are there?
What’s a foreign key? How can they help us design schemas with relational data?
User stories
As a shopper, I want to:
See a homepage with content when I log in
Be able to navigate between different pages of the app
View a list of products when I visit the products page
Click on a product to view more details in a new page
Search for products by name or description and view product listings with images, descriptions and reviews
Add products to a shopping cart
Stretch user stories
View and edit items in my shopping cart
Complete the checkout process to "purchase" products in my cart
See confirmation when an order is placed successfully
View previous orders and order history
Complete checkout and payments to simulate purchasing products
Repository naming convention
Please name your repo following this template: PRO04_Name1_Name2_Name3_Name4
Acceptance criteria
Stretch
Component testing in React
Writing maintainable and readable test cases
Configuring environment variables for different deployment stages
Setting up and configuring cloud platforms (AWS EC2)
Managing CORS policies in deployed applications
Configure environment variables for different deployment stages
Document the setup, deployment process, and usage instructions
This week focuses on enhancing the e-commerce web application developed in the previous week by adding authentication, user-specific interactions, and improving overall security. The emphasis is on implementing secure user authentication and authorization while expanding React state management techniques.
Workshops
Learning Outcomes
Authetication
React
Execute Program
Finish previous courses
Topics
User authentication and authorization in web applications
Secure handling of user registration, login, and logout
Session management (stateless vs stateful approaches)
Security threats and mitigation strategies (e.g., CSRF attacks)
React Router for multi-page navigation
Advanced React state management using Context API and useReducer
Linking user accounts with shopping carts and order history
Database security and user data protection
Project
Continue developing the e-commerce application with the following new features:
Implement user authentication (registration, login, logout)
Create user-specific shopping carts and order history
Implement session persistence
Secure the application against common web vulnerabilities
Enhance React state management using Context API and useReducer
Implement multi-page navigation using React Router
Additional Skills
Implementing role-based access control (for admin functionalities)
This week focuses on testing, deployment, and optimization of the e-commerce web application developed over the past two weeks. The emphasis is on implementing comprehensive testing strategies, deploying the full-stack application to AWS, and setting up continuous integration and deployment pipelines.
Writing and organizing unit tests, integration tests, and end-to-end tests
Mocking external dependencies in tests
Understanding and configuring different deployment environments (development, staging, production)
Project
Develop a comprehensive testing strategy for the e-commerce application
Implement tests using Cypress, Postman, and Node's testing library
Create a deployment plan for AWS infrastructure
Stretch Goals
Set up a GitHub Actions CI/CD pipeline for automatic deployment on push to main
Implement staging environments in addition to development and production
Optimize application performance for production environment
Additional Skills
Code organization and modularization for testability
Advanced TypeScript usage in testing and deployment scripts
Understanding of cloud architecture and best practices
This week brings together all aspects of the software development lifecycle, from testing to deployment, providing a holistic view of bringing a web application to production. It emphasizes the importance of thorough testing, secure and scalable deployment practices, and the use of modern DevOps tools and techniques.
Infrastructure as Code concepts and implementation with AWS CDK
AWS resource provisioning and configuration (EC2, S3, security groups)
Environment variable management across different deployment stages
Continuous Integration and Continuous Deployment (CI/CD) pipelines
Optimizing applications for production deployment
AWS permissions and security best practices
Deploy the backend to an AWS EC2 instance
Host static frontend files on an AWS S3 bucket
Set up and configure necessary AWS resources (e.g., security groups, IAM roles)
Implement Infrastructure as Code using AWS CDK
Configure environment variables for different deployment stages
Document the setup, deployment process, and usage instructions
Debugging deployment issues in cloud environments
Writing clear and comprehensive technical documentation
week09-reading-week
schedule
Learning Outcomes
Testing
Deployment
project
Project
Your task this week is to deploy and test the e-commerce app you have completed in the previous two weeks.
Spike
Before you start you need to create a testing and deployment plan. We would like you plan a testing strategy that will have broad coverage of your project. The tools we would like you to use to achieve this can include Cypress, Postman and the Node built in testing library.
We would also like you to deploy this project using an EC2 instance for you server and a S3 bucket to serve your static files.
Questions to consider
What parts of the application logic are the most critical to cover with unit tests?
How will you mock external dependencies (like databases or APIs) during unit testing?
What are the key user journeys and flows within the application that must be covered by end-to-end tests?
Acceptance Criteria
Stretch
project
Project
Your project this week is continue work on the e-commerce shop you started last week and to add authentication and user specific interactions.
Spike
Before you start writing features you need to create a security plan. There should be a section in your README.md that describes how you will secure your app and mitigate different potential attacks.
Questions to consider
Will you store session info in a token (stateless) or in your database (stateful)?
How will you check a user’s identity (authentication)?
How will you control what actions a user can take (authorization)?
Useful resources
User stories
As a shopper, I want to:
Log into my account using my email and password
Have my user session persist, so I don't have to log in every time
Log out of my session
These User Stories from last week should be updated to be linked to a shoppers account
Add products to a shopping cart
View and edit items in my shopping cart
Complete the checkout process to "purchase" products in my cart
These resources are helpful extra reading that may clarify or enhance concepts you’re learning in the main curriculum.
JSON Web Tokens Suck Despite the title this talk actually covers most aspects of web authentication in a very accessible way
A short guide to useReducer and useContext
How to work with cookies while you are developing
Node based examples of the what and how of CSRF protection
The 8 Principles of Secure Development & Deployment set out by the National Cyber Security Center
overview
Week of November 4th
.NET
Route 01. Csharp Certification
This option focuses entirely on mastering C# before diving into broader .NET concepts. The goal is for you to gain a strong command of the language and become comfortable with its infrastructure. By Week 10, you'll be able to apply what you’ve learned to a hands-on project.
To start, please register on both FreeCodeCamp and Microsoft Learn. You’ll access the learning modules via FreeCodeCamp links, which will track your progress and give you the opportunity to sit for a Microsoft Certification exam upon completion.
The next course is not part of the certification, but it is a great short example of minimal API.
Route 02. Blended C# and Infrastructure Approach
In this route, you'll combine learning C# with workshops focused on infrastructure essentials. This approach balances language fundamentals with practical infrastructure skills to give you a well-rounded foundation.
You can complete the first three C# lessons independently or through FreeCodeCamp. If you choose the FreeCodeCamp route, you’ll have the option to continue with the remaining lessons later and eventually take the Microsoft Certification exam.
This week focuses on building a library management system using .NET for the backend and React for the frontend. The emphasis is on creating a robust backend API with ASP.NET Core and implementing user authentication and data persistence with PostgreSQL or SQLite.
Core Topics
ASP.NET Core Web API development
Database design and implementation with PostgreSQL/SQLite
Object-Oriented Programming in C#
Project Development Focus
Setting up ASP.NET Core backend
Implementing database schema for library items
Creating RESTful API endpoints
Learning Objectives
Building secure and scalable backend services with .NET
Implementing proper data models and relationships
Managing user authentication and authorization
PHP Path
This week introduces WordPress development using PHP, focusing on theme and plugin development, and understanding the WordPress ecosystem.
Core Topics
Local WordPress development environment setup
WordPress theme development fundamentals
PHP basics for WordPress
Project Development Focus
Setting up local development environment
Creating custom WordPress themes
Understanding WordPress file structure
Learning Objectives
Understanding WordPress architecture
Creating custom themes from scratch
Working with WordPress template system
Resources
These resources are helpful extra reading that may clarify or enhance concepts you're learning in the main curriculum.
Learners with build a library in which to sort and share information (i.e. music, photos, recipes etc...). Potential users should be able to view, favourite and upload items as well as make collections and view ones created by other users.
The frontend of this project will be built using React. For the backend, it will use ASP.NET to handle server-side functionality. User accounts and item lists will be stored in a PostgreSQL or SQLite database.
Project
Your project for the next 3 weeks will be to develop a .NET backend connected to a database and linked to a React frontend. This week you should start by building the backend and testing it with Swagger (.NET equivalent to Postman). Tests should cover the creation users and endpoints related to user content.
Spike
Like the last project you will benefit by building a scheme for your database before you start. Hopefully with what you learned from last projects you are ready to think about how things will connect and consider what sorts of endpoints you will want. Finally, think about what you have done for stretch goals on previous projects and see if you can come up with a different sort of goal this time. For example if you've been stretching yourself by adding technical complexity try focusing on design or UX/UI instead.
Questions to consider
What endpoints will you need for your app?
What sort of classes will you need to match your data and how will these be represented in OOP (object orientated programming)?
Useful resources
User stories
As a user, I want to:
Login to an individual account
See my collections of items and favourites
Search and look at other users collections
Stretch user stories
Follow other users
Make sure users can only edit their own collections and items
Stop duplicate items being uploaded
Repository naming convention
Please name your repo following this template: PRO05_Name1_Name2_Name3_Name4
Acceptance criteria
Stretch
PHP
Project Overview: Building a Custom WordPress Site with Theme and Plugin Development
Over the next three weeks, you will develop a fully functional WordPress website from scratch. Starting with setting up your local development environment, you'll create a custom theme tailored to your design preferences, incorporating dynamic content using The Loop and interactive elements with TypeScript. You'll then plan and build a custom plugin to add significant functionality to your site, such as an event manager or testimonials feature, utilizing custom post types, taxonomies, and AJAX for dynamic updates.
In the final week, you'll focus on deploying your site to a live hosting environment, implementing security best practices, and optimizing performance. By integrating your custom plugin with your theme, you'll create a seamless user experience. This project will enhance your proficiency in WordPress development and PHP programming, providing you with valuable skills and a portfolio-worthy website.
Foundations of WordPress and PHP
Monday: Setting Up the Development Environment
Objectives:
Set up a local server environment for WordPress development.
Install and configure WordPress locally.
Tuesday: Introduction to WordPress Theme Development
Objectives:
Understand how WordPress themes work.
Begin developing a custom theme from scratch.
Wednesday: Advanced Theme Customization
Objectives:
Add features to the custom theme.
Integrate TypeScript for front-end interactivity.
Thursday: Presentation Preparation and Delivery
Objectives:
Prepare and deliver a 20-minute presentation showcasing the custom theme.
Continue normal development activities.
Friday: Working with WordPress Database
Objectives:
Learn to interact with the WordPress database using PHP.
Understand data sanitization and security best practices.
Week of November 18th
.NET Path
This week focuses on improving code quality and testability of the library management system through dependency injection and comprehensive testing strategies.
Core Topics
Testing and deployment
.NET
Dependency Injection principles in .NET
Unit testing with .NET testing frameworks
Test-driven development practices
Code organization and solution architecture
Mock databases for testing
Code refactoring techniques
Project Development Focus
Implementing dependency injection
Writing comprehensive API tests
Refactoring code for better maintainability
Creating mock objects for testing
Improving project structure
Implementing verification systems
Learning Objectives
Understanding dependency injection concepts
Writing effective unit tests
Mocking dependencies for testing
Refactoring code for better testability
Implementing verification systems
PHP Path
This week focuses on advanced WordPress development, including custom plugin creation, theme integration, and implementing dynamic features using AJAX and APIs.
Core Topics
Custom plugin development
WordPress hooks and filters
AJAX implementation in WordPress
External API integration
Shortcode creation and usage
Front-end integration techniques
Testing and documentation
Project Development Focus
Planning plugin functionality
Creating custom post types and taxonomies
Building admin interfaces
Implementing AJAX features
Integrating with external APIs
Creating shortcodes
Writing documentation
Learning Objectives
Building custom WordPress plugins
Working with WordPress APIs
Implementing dynamic features with AJAX
Creating responsive and accessible interfaces
Testing WordPress applications
Writing technical documentation
Testing
week12-project05-DOTNET-deploy
View individual items details
Save items or collections from other users
Upload and add items
Suggest collections based on favourites
Understand the WordPress file and folder structure.
Activities:
Install a Local Server Environment:
Choose and Install Software:
Windows Users: Download and install .
Mac Users: Download and install .
Configure the Server:
Start Apache and MySQL services from the control panel.
Testing with a ASP.NET project although the project and set up might be a bit different from yours
The official xUnit documentation
Week of November 25th
.NET Path
This week focuses on deploying and testing the library management system, emphasizing comprehensive testing strategies and cloud deployment using AWS services.
Core Topics
Testing strategies and methodologies
AWS deployment architecture
CI/CD with GitHub Actions
Infrastructure as Code
Environment configuration management
Cloud service integration
Project Development Focus
Implementing unit tests
Creating integration tests
Setting up end-to-end testing with Cypress
Deploying to AWS EC2 and S3
Learning Objectives
Understanding different testing approaches
Implementing comprehensive test coverage
Managing cloud infrastructure
PHP Path
This week focuses on WordPress deployment, security, and optimization, covering hosting solutions, migration processes, and performance tuning.
Your task this week is to continue building the project from last week but to try and add some .NET tests and more broadly to use dependency injection.
Spike
Before you start think what are your dependencies. Which of these are tightly tied to other classes in a way that will slow development or make testing hard. If you want to replace this with dependency injection think what will the interface look like.
Questions to consider
What do you want the structure of your project to look like and how should the solution file be configured to allow that?
Where do you want to use dependency injections in my code?
How will you test the functionality of the API?
Acceptance Criteria
Stretch criteria
PHP
Building the Custom Plugin and Theme Integration
Monday: Planning the Plugin Functionality
Objectives:
Define the plugin's purpose, features, and data requirements.
Design the database schema if needed.
Tuesday: Developing the Plugin Backend
Objectives:
Start coding the core functionality of the plugin.
Create custom post types and taxonomies.
Wednesday: Enhancing the Plugin with AJAX and APIs
Objectives:
Implement dynamic features using AJAX.
Integrate external APIs if applicable.
Thursday: Presentation Preparation and Delivery
Objectives:
Prepare and deliver a 20-minute presentation showcasing the plugin progress.
Continue normal development activities.
Friday: Front-End Integration and Shortcodes
Objectives:
Connect the plugin with the theme.
Provide user-facing features using shortcodes and widgets.
project
.NET
Your task this week is to deploy and test the library app you have completed in the previous two weeks.
Spike
Before you start you need to create a testing and deployment plan. We would like you to plan a testing strategy that will have broad coverage of your project. The tools we would like you to use to achieve this can include Cypress, Postman and the Node built in testing library.
We would also like you to deploy this project using an EC2 instance for you server and a S3 bucket to serve your static files using CloudFront. You should also utilise Github actions to allow you to automatically deploy changes on merges to your main branch.
Questions to consider
What parts of the application logic are the most critical to cover with unit tests?
How will you mock external dependencies (like databases or APIs) during unit testing?
What are the key user journeys and flows within the application that must be covered by end-to-end tests?
Acceptance Criteria
Stretch
PHP
Deployment and Advanced Topics
Monday: Exploring Deployment Options
Objectives:
Learn about standard WordPress hosting solutions.
Compare AWS with managed WordPress hosting providers.
Tuesday: Preparing for Deployment
Objectives:
Set up the chosen hosting environment.
Migrate the local WordPress site to the hosting server.
Wednesday: Securing and Optimizing the Site
Objectives:
Implement security best practices.
Optimize the site's performance.
Thursday: Final Adjustments and Presentation
Objectives:
Finalize the deployment of the WordPress site.
Prepare and deliver the final 20-minute presentation.
Please name your repo following this template: PROTFB_Project_Name
Your project in Design Week is to create a wireframe in Figma and test it with your Product Owners' user group.
Take ideas from your Definition workshop and the sketches you did there. You can consider the ideas you came up with there as low-fidelity prototypes and with Figma, you'll create a high-fidelity prototype.
Your wireframe should include the main steps of the user journey. Think about which parts of the journey you'd like to get feedback on from your users and prioritise building these.
<?php
class Event_Manager {
public function __construct() {
add_action( 'init', array( $this, 'register_custom_post_type' ) );
}
public function register_custom_post_type() {
// Registration code here
}
// Additional methods
}
$event_manager = new Event_Manager();
?>
<?php
namespace MyPlugin;
class Event_Manager {
// Class code
}
?>
function my_ajax_action() {
$data = $_POST['data'];
// Process data here.
echo 'Received: ' . $data;
wp_die(); // All AJAX handlers should die when finished.
}
add_action( 'wp_ajax_my_ajax_action', 'my_ajax_action' );
add_action( 'wp_ajax_nopriv_my_ajax_action', 'my_ajax_action' );
define('DB_NAME', 'yourusername_wpdb');
define('DB_USER', 'your_db_username');
define('DB_PASSWORD', 'your_db_password');
define('DB_HOST', 'localhost'); // Often 'localhost', check with your host