• Ahmet Bayir
• Ahmet Firat Gamsiz
• Asya Su Sen
• Arda Yalcindag
• Isil Su Karakuzu
• Mehmet Batuhan Cok
• Orhan Unuvar
• Soner Kuyar
• Taha Ensar Kukul
• Yusuf Aygun

Playlog is a social platform designed for gamers, offering a range of features to enrich the gaming experience and foster community interaction. Serving as a centralized hub, Playlog allows users to explore, catalog, and engage with their favorite video games. Whether you're a casual player or a dedicated enthusiast, Playlog provides an immersive environment with an extensive library of games to discover and connect with fellow gamers.

A standout feature of Playlog is its semantic browsing, allowing users to explore games based on properties like genre, platform, and developer. This approach enhances game exploration by providing deeper insights into the gaming landscape. Additionally, users can participate in the gaming community through features like reviews, ratings, and personalized lists, fostering social interaction and engagement.

Playlog focuses on making gaming easy, safe, and enjoyable for everyone. We follow industry standards to keep your data secure and the platform running smoothly, even during busy times. With Playlog, you get a complete gaming experience that's easy to use, lets you connect with others, and lets you explore games that match your interests.

Currently, we've completed all diagrams illustrating user interactions and app functionality. We've organized ourselves into backend, mobile, and frontend teams, although these may change as tasks evolve. Our requirements have been updated based on TA feedback, and our mockups now align with our scenarios.

In the implementation phase, we've built Login, Sign-up, Game, and Main Pages with their functions, including the "Game of the Day" feature with three endpoints. We'll continue to add more endpoints and semantic queries. Additionally, we've created a Swagger API specification for local access and provided detailed documentation in ./README.md for both local and DigitalOcean deployment. Each sub-team has its README explaining their processes. Deployment-wise, we utilize a DigitalOcean cloud computer and necessary Docker and Docker-Compose files.

You can view our current progress in our completed requirements below:

• 1.1.1.1. Guests shall be able to register to the application by providing their email, username, and password.
  • 1.1.1.1.1. Provided email and username shall be unique.
  • 1.1.1.1.3. Provided username shall be at least 8, at most 16 characters.
  • 1.1.1.1.6. Provided password shall be at least 8, at most 32 characters.
  • 1.1.1.1.7. Provided password shall include at least 1 lowercase letter, 1 uppercase letter, and 1 digit.
• 1.1.1.2. Guests shall be able to log in to the application by providing their email and password.
• 1.1.2.3. Users shall be able to view a game.
• 1.2.4.6. System shall query properties, retrieve existing ones and display them.
  
• 2.1.1. The application shall have an intuitive user interface with clear navigation paths and interactive elements.
• 2.1.3. The application shall provide informative feedback to users for their actions, such as successful registrations, login attempts, and error messages for failed actions.
• 2.2.1. Users shall be able to access the application from various web browsers, including popular options like Chrome, Firefox, Safari, and Edge.
• 2.2.2. The application shall be in English.
• 2.3.1. The passwords stored in the database of the system shall be encrypted using the default encryption provided by Django.
• 2.5.1. The application shall follow KVCC privacy rules.

• URL to GitHub code repository
• URL to the pre-release

• Playlog deployment URL

• We have directories named ./frontend, ./backend, and ./app/mobile/Playlog (which will later be changed to ./mobile), each containing the respective codebase for the frontend, backend, and mobile applications. Each codebase has its own readme file explaining setup, running the application, and making changes based on the codebase. We use docker-compose for building and deploying the application.

• Additionally, we have our API specification, with a Swagger UI instance available in our local docker-compose setup at localhost:8000/swagger.

• When working with Docker, the initial setup might take a while as it fetches and sets up the required components. This could take tens of minutes or more, depending on your internet speed and system capabilities. Don't worry if it seems to be taking a long time. Just be patient and let it finish. As long as the build moves forward smoothly without any errors, you're on the right track. It's usually just a waiting game until it's done.

  1. Clone the Repository:

     • Open your terminal or command prompt.
     • Navigate to the directory where you want to clone the repository.
     • Use the following command to clone the repository:

       git clone -b dev <repository_url>
       

     Replace <repository_url> with the URL of the repository you want to clone.

  2. Navigate to the Repository:

     • Once the cloning process is complete, navigate to the cloned repository directory using the cd command:

       cd <repository_name>
       

     Replace <repository_name> with the name of the cloned repository.

  3. Build and Run Docker Compose:

     • Make sure you have Docker and Docker Compose installed on your system.
     • Run the following command to build and start Docker Compose:

       docker-compose up --build
       

     This command will build the Docker images and start the containers defined in your docker-compose.yaml file.

  4. Access the Frontend and Backend:

     • Once Docker Compose has successfully started the containers, you can access the frontend at localhost:3000 and the backend at localhost:8000 in your web browser.

• To deploy our application on DigitalOcean follow these instructions:

  1. Sign up to Digital Ocean and create a project.
  2. From left menu click on "Droplets" and click on "Create Droplets".
  3. Choose region, datacenter and a machine. Increase machine capabilities if you have errors. For image click on marketplace and select Docker.
  4. Write down a password and save it for later. Click on create droplet.
  5. Wait until droplet is created and copy IP address from Droplets page.
  6. Open up the terminal and connect to droplet by "ssh root@<ip_address>" command.
  7. Once connected to machine install docker-compose with "apt install docker-compose"
  8. Clone the repository by typing "git clone https://github.com/bounswe/bounswe2024group12.git".
  9. Enter into repository by typing "cd bounswe2024group12/"
  10. In the repository create .env file with "nano .env" command.
  11. Inside the .env write the following (You can set <text> parts arbitrarily): "MYSQL_ROOT_PASSWORD=<root_password> MYSQL_DATABASE=playlog_db MYSQL_USER=<user> MYSQL_PASSWORD=<mypassword> DJANGO_SECRET_KEY=<django_secret_key>"
  12. After saving and exiting (ctrl x followed by y) run "docker-compose up --build" command.
  13. Make sure frontend and backend were able to be successfully built (ignore the warnings). After that you can access the website by typing <ip_address>:3000 to your browser.

• You can view our Class Diagram by following this link: Class Diagram

• You can view our Use Case Diagram by following this link: Use Case Diagram

• You can view our Sequence Diagrams by following this link: Sequence Diagrams

• You can view our Project Plan by following this link: Project Plan
• You can view our RAM by following this link: Responsibility Assignment Matrix

• Meeting #8 ‐ 17.04.2024
• Feedback Meeting - 17.04.2024
• Meeting #7 ‐ 27.03.2024
• Meeting #6 ‐ 22.03.2024
• Backend ‐ Meeting #1 ‐ 21.04.2024
• Frontend ‐ Meeting #1 ‐ 20.04.2024

We utilized GitHub for developing and maintaining our code. GitHub's branch management and issue tracking were invaluable. We established three branches: backend-dev, frontend-dev, and mobile-dev. Each feature was initially merged into one of these branches, then into the 'dev' branch for comprehensive testing. Once testing was complete, we merged our code into the 'main' branch. We extensively utilized the README.md files; each sub-team provided instructions on running their respective parts, enabling us to make changes to our code effortlessly. Additionally, GitHub's commit tracking feature was beneficial; we iterated back and forth between commits to explore different approaches in our codebase.

We used our Discord server to communicate effectively with each other. We created three categories: frontend, backend, and mobile, each with its own voice and text channels. This setup allowed us to discuss our team's progress separately while also viewing the chat from other teams. This feature greatly streamlined our work and communication. Additionally, we utilized voice channels for inter-team gatherings.

Django is a Python-based framework that we selected for our backend development. We chose Django because Python is notably easy to learn and use, and it offers a wealth of abstractions. Additionally, Django comes with a multitude of pre-implemented functions; for instance, user hashing and authentication are already built-in. Django's extensive documentation proved to be immensely helpful. With numerous Django tutorials available, we easily found solutions to any issues we encountered. Furthermore, Django seamlessly integrates with SQL, simplifying database interactions.

React is a JavaScript library for building user interfaces, which we adopted for our project's frontend development. We chose React primarily because of its component-based architecture, which allows for efficient code reusability and the creation of dynamic and interactive user experiences. React's use of a virtual DOM optimizes rendering, making it exceptionally fast and suitable for high-performance applications.

One of the key features of React that we used extensively is its state management capabilities. By maintaining the login status and checking dynamic states, React ensures a good user experiences without reloading the page. This state management is crucial for features like user authentication, where the UI needs to update reactively based on user interactions and changes in authentication status.

Furthermore, React's ecosystem includes a robust set of tools for making API calls, such as Axios and Fetch API(we used the fetch), integrated within the React lifecycle methods or hooks like useEffect. This integration simplifies handling asynchronous data fetching, updating the UI in response to data changes, and interacting with back-end services. Also we use its State preserving naviagate function for routing.

React Native is a framework for building mobile applications using JavaScript and React. We chose React Native for our mobile application development because it allows us to write a single codebase that can run on both iOS and Android devices. This approach saves development time and resources, as we only need to maintain one codebase for both platforms.

React Native provides a set of pre-built components that are optimized for mobile devices, allowing us to create a native-like user experience. These components include buttons, text inputs, lists, and navigation elements, which we used to build the various screens and features of our mobile application.

Furthermore, React Native's hot reloading feature enables us to see changes to our code reflected in the mobile application in real-time, without the need to recompile or restart the app. This feature greatly speeds up the development process and allows us to iterate quickly on new features and improvements.

Postman is a widely-used API client tool that simplifies testing, documenting, and sharing APIs. It allows users to send requests, inspect responses, and collaborate with team members. We employed Postman to test backend endpoints collaboratively within our team, and its team workspace feature facilitated monitoring of incoming and outgoing JSON data between frontend and backend teams.

Docker is a tool that simplifies how developers package and run their applications, ensuring consistency and ease of deployment. We utilized Docker to create three containers: frontend, backend, and database. Containerization enabled us to deploy our project on DigitalOcean and run it anywhere. With Docker Compose, we efficiently managed the three containers, automating tasks such as installing requirements. Additionally, hosting our database on a server rather than locally was crucial, as it allowed us to store data from various sources, making a local setup impractical.

DigitalOcean offers scalable cloud infrastructure and services for developers and businesses, simplifying application deployment and management. We deployed our project using Docker on a DigitalOcean machine. After connecting to the machine via SSH, we pulled the repository using 'git pull' and installed Docker Compose with 'sudo apt-get.' Finally, we ran the project within the DigitalOcean server.

After initially holding weekly meetings on Wednesdays at 20:30, our meeting frequency gradually decreased over time. Following the Ramadan holiday, we faced challenges in regaining focus on our project. Subsequently, following the completion of our first milestone, the frontend, backend, and mobile teams began convening online via Discord to discuss project matters. Moving forward, we aim to enhance the quality and consistency of our meetings.

We mainly organize our project workflow through GitHub's issue management system. After reaching milestone 1, issues are now divided equally among authors, rather than just one person opening them. Additionally, the quality of our issues has significantly improved. We're adding reviewers more frequently, and we're now having discussions under the relevant issues, as intended. However, one problem we encountered with issues was not knowing which ones to open when initializing our project's code. Unfortunately, we also ended up doing a lot of things last minute, especially in the backend, which made the last few issues a bit messy and incomplete. We'll make an effort to avoid this in the upcoming milestone.

We learned how to design a mobile and web project from scratch, which involved creating use case, class, and sequence diagrams for smooth development. Our learning covered various aspects of frontend, backend, and mobile development, including tools like Django, React, and React Native. Additionally, we gained insights into managing branches in GitHub for larger projects integrating web and mobile apps. We explored APIs, constructing endpoints and connecting them to both frontend web and mobile applications. Database management using MySQL was another skill we acquired. We also learned how to containerize our project using Docker and properly manage containers using Docker Compose. Effective issue tracking and discussion were emphasized. Finally, we deployed our project on DigitalOcean for broader visibility.

We discovered that teamwork is a challenging skill to develop, and we encountered instances where things didn't go according to plan smoothly. In such situations, our team members made efforts to compensate for any shortcomings, whether intentional or unintentional, to ensure the project's success. We acknowledge the significance of active involvement and communication within sub-teams. Learning from this, we are dedicated to keeping all team members on task.

The first challenge we faced was regrouping and motivating our team after the Ramadan break. We initially felt somewhat exhausted and disconnected, resulting in meetings and tasks falling slightly behind schedule. However, once we began working on the sequence diagrams, our team regained its momentum and became more productive. Moving forward, we aim to stay engaged with our projects during extended breaks, as re-engaging with a project after distancing ourselves can be challenging.

Our team lacked experienced members in React, React Native, and Django. While some of us had related experience, this project presented new and challenging tasks for everyone. We had to conduct thorough research and build everything from scratch, leading to long hours spent resolving bugs and ensuring the project ran smoothly. Learning a new tech stack within a short timeframe proved to be difficult, yet incredibly educational.

Our backend sub-team encountered challenges, whether intentionally or due to health issues, resulting in incomplete tasks. Other team members stepped in to help the backend team meet Milestone 2 deliverables. Despite not being initially familiar with Django, they devoted significant time and effort to learning and implementing the backend portion, which was demanding for them. The lack of participation from the backend team caused tension within the entire group. Moving forward, we recognize the importance of equal participation and communication within sub-teams. We've learned from this experience and are committed to ensuring that all team members stay on track with their tasks.

Contribution	Issue Link	Wiki Link

Contribution	Issue Link	Wiki Link
I created a use-case diagram that following the project requirements	#104	Use Case Diagram
I arranged the project plan for frontend, backend, deployment and testing. I set up and keep updated milestone dates and connected issues to relevant milestones. I organized the project roadmap pages and put issues under relevant segments.	#108, #120	Project Plan
I included more details for backend and deployment in RAM	#174	RAM
I have reviewed a great number of issues and gave many feedbacks. I gave a lot of effort to keep issues organized by keeping labels, project and milestone segments updated for every issue.	--	--
I have worked on team organization, reaching out to team members, checking up with them and making emergency arrangments.	--	--
I have attended to TA feedback meeting and report TA's feedbacks. I have made updates on requirements accordingly.	#123, #125	Feedback Meeting , Requirements
I implemented login and sign up functionalities on frontend. I checked user input according to requirements and made calls to backend using Fetch API.	#122, #131
I implemented persistent login status and abled users to browse as guest. I included an authorization token for this.	#135
I built a simple express.js server for testing backend connections.	#131	Server Gist
I implemented RegisteredUser table in backend. I created sign up and login views, which serves as API endpoint for frontend and updates our User model. I also fixed CORS related issues	#180
I fixed Docker containers' communication issue. I deployed frontend, backend and database containers on DigitalOcean	#172	Playlog deployment URL

• I had some troubles with understanding how use-case diagram should be structured overall.
• Due to emergency in backend I connected with most of the team members to divert some of them to backend team for short term. No one approved on this and the remaining team member at backend didn't report their status in the weekend. That was disappointing and very difficult to plan accordingly.
• I had to code the backend last day before demo without having any prior Django knowledge (I am normally on frontend team). I had encountered a bug that prevented updating database which was very troublesome. The bug had a very simple fix which was a frustration.

Contribution	Issue Link	Wiki Link
I created the class diagram with Orhan Unuvar and Batuhan and updated it according to feedbacks. We've also had a meeting about the properties of the class diagram.	#107	Class Diagram
I implemented and updated the front-end side of the main page of our application while adding in new template components.	#132	Main Page
I implemented and updated the front-end side of the game page of our application while adding in new template components.	#136	Game Page
I wrote an installation guide for the front-end.	#175	-
I researched and solved a front-end bug about multiple renders. First I tried to fix it then after researching I've documented the reason for it.	#170	-
I attended to TA feedback meeting and I updated requirements non functional part according to feedback from our TA.	#117	Requirements
I gave feedback to the mockups according to the requirements and our meeting with the TA	#99, #116	-
I attended our weekly meetings and front-end meetings. I've also attended the emergency meetings and helped with the bugs occuring in the back-end.	--	--
I tested and reviewed different back-end and front-end tasks.	--	--

• I had difficulties using Django since I'm not used to it. Ahmet and I got really stuck on a bug during the emergency meeting.
• I've had difficulty keeping track of the issues that I were assigned to review due to "Status: Review Needed" label not being used properly.
• After tasks were distrubuted I planned my time accordingly finished them early on but due to back-end being stuck and late I had to cancel my other plans.

Contribution	Issue Link	Wiki Link
Conducted a meeting with Ahmet Bayir and added mockups to scenarios.	#103	-
Solved some issues about the scenarios. Those issues were about compatibility with requirements.	#111	-
Conducted a backend meeting and researched about Django REST framework as in the action items.	-	Backend Meeting

• We left the backend part to the last weekend and I have some personal medical issues which prevented me from accessing my computer. So I couldn't contributed much about this milestone. When I was available, the most of the work was done.
• I haven't any experience about software development before, therefore learning about the the tools and frameworks was very challinging for me since we haven't much time to learn properly.

Contribution	Issue Link	Wiki Link
I created items numbered 5, 6, and 7 on the sequence diagrams page, collaborating with Yusuf Aygun and Ahmet Bayir. Furthermore, we convened a meeting to discuss the characteristics of the sequence diagrams and the process of creating them using Mermaid.	#106	Sequence Diagrams
I participated in Meeting 6-7-8 and Backend Meeting 1, where I took notes and documented them on the wiki.	#124	Already in report.
I initialized the Django app for the backend side of the project, organized the file structure, and set up .env variables. Additionally, I created a MySQL database and connected it to our backend project.	#126, #134	-
I created a Dockerfile for the backend and a docker-compose file that sets up two Docker containers for the database and backend components of the project.	#133	-
I wrote an installation guide for the backend, detailing how to run the backend portion, test it, and observe changes locally. Additionally, I provided instructions for Docker containerization.	#175	Back-end Guide
I integrated Swagger into Django for API specification.	#177	-
I reviewed Ahmet Firat Gamsiz's Django code for the Login and Sign-up pages. While I had also written these functionalities, we opted to use Ahmet's code as it was more suitable.	#180	-
I updated our project's main README file by including sections for Architecture and Local Deployment. Additionally, I integrated Ahmet Firat's Deployment part.	#184	Main README.md
I established the directory structure and Git branch organization for our project. I merged changes from the frontend-dev and backend-dev branches into the dev branch, resolving any conflicts and conducting manual testing to ensure compatibility.	-	-
I have updated the dev branch to align with recent changes, as some teammates unintentionally pushed to the main branch, causing it to fall behind. Additionally, I have corrected the tree structure of our repository. Furthermore, I have made necessary adjustments in the frontend part of the dev branch to ensure that team members can work locally in Docker containers. This is vital for accessing Swagger and drafting local deployment guides, as they are dependent on these changes.	Part of #185 (not finished yet.)	-
I've written all of the Milestone 2 report, except for tasks including adding application URLs, detailing DigitalOcean deployment procedures, evaluating React and React Native tools, and compiling the table of teammates' individual contributions.	#183	Milestone 2 Report

• I struggled to stay motivated after the break and missed a few deadlines for adding meeting notes to the wiki. However, the notes were accessible to our teammates on Drive.
• Working with Django was manageable, but I encountered significant challenges with connecting the backend to the database. Setting up environment variables and configuring Docker files and docker-compose.yaml from scratch proved to be quite difficult. I encountered numerous errors and spent a considerable amount of time troubleshooting them.
• Unfortunately, due to personal matters such as a competition in Ankara and a family health issue, I couldn't dedicate as much time to backend development as planned. To make up for it, I managed branch operations, conducted manual testing, made substantial contributions to the Milestone 2 report, and developed deployment and backend guides. Additionally, I created the Swagger documentation for API specification.
• Before the demo day, I had to pull an all-nighter to assist our group in preparing thoroughly, contibuting everything from implementation to dockerization and deployment.

Contribution	Issue Link	Wiki Link
I created the class diagram with Asya Su and Orhan and updated it according to feedbacks. We've also had a meeting about the properties of the class diagram	#107	Class Diagram
I attended our weekly meetings and backend team meetings	--	--
I made considerable efforts to research and implement user authentication (failed)	#96

• As a newcomer to software development and Django framework, I faced significant challenges in understanding the intricacies of backend development. My unfamiliarity with Django and Docker, coupled with no prior experience in group projects, made it difficult to contribute effectively to the team. This lack of experience resulted in prolonged task completion and increased the workload for other teams.
• Despite dedicating considerable time to researching and attempting to implement user authentication, I encountered difficulties in successfully integrating it into the project due to my lack of experience in group projects.

Contribution	Issue Link	Wiki Link
I created a Google Forms to collect the experience of each group member to divide our group into backend, web, and mobile teams.	#101	Subteams Form
I created a Google Forms to collect the opinion of each group member to decide the name of our application.	#102	Application Name Form
I created the class diagram with Asya Su Sen and Mehmet Batuhan Cok and updated it according to feedbacks. We also had a meeting about the properties of the class diagram.	#107	Class Diagram
I arranged the project plan for the mobile team.	#108, #120	Project Plan
I updated the RAM for the mobile team.	#173	RAM
I made fixes and updates on requirements according to the feedback from the TA and the other team members.	#123	Requirements
I implemented the ReviewListCard, MainPageReviewCard, MainPageBanner, and SmallRatings components for the mobile application.	#145, #146, #147, #149
I created a SPARQL query to search for game properties using the Wikidata Query Service.	#181

• I had to learn React Native from scratch to contribute to the mobile team. I had never used React Native before and I had to learn it in a short time. I had to watch tutorials and read the documentation to learn React Native.
• I had to stay up all night before the morning of the demo day to help our group fully prepare for the demo, including all implementation, dockerization, and deployment.

Contribution	Issue Link	Wiki Link
I re-organized the Scenario 5 with Ahmet Bayir (He edited and added the mockups according to scenario) to reflect properties of requirements elements which are not mentioned at the other scenarios and mainly focused on semantic browsing.	#105	Scenario 5
I re-organized the RAM with Yusuf Aygün to reflect subteam works properly. I divided the responsibilities after Milestone 1 and pointed out which responsibilities are for backend, frontend or mobile.	#109	RAM
I created the React-app for frontend side of the project. Organized file structure, deleted unnecessary folders, dependencies and tests. After that, I worked on styling of the project, wrote a globals.css, fonts.css. Decided on css's of headers, buttons, etc...	#118	--
I designed the Sign-up and login pages. Also added common card component to help my teammates create a unified style across the app.	#121	--
I implemented the functionalities for login and signup page with Ahmet Fırat. I started with the general form controls (naive control of empty input, mail, checkbox), implemented page routing, scheduled router for signup successful page and reset password pages. Also designed and added Terms And Privacy pop-ups.	#122	--
I added a draft of reset password endpoint to Ahmet Fırat's Server.js and tried and reviewed his API draft implementation in Node.js.	#131	--
After the first developments of me, Asya and Ahmet Fırat, there was a necessity in Frontend-development of resolving conflicts, merging branches and unifying the file structure for docker containerization. I've done these tasks.	#151 and #154	--
I revised Sparql query that I've gotten from Orhan Unuvar. Then, I implemented a backend endpoint for the game of the day.	#168 and #181	--
I implemented game-of-day API call mechanism in the Frontend. I edited the section under game image, designed it to fetch the data from backend so Wikidata.	#169	--
I wrote a backend endpoint function to which take game_name as input then returns all the properties about the game_name matches in WikiData API. Also added dynamic routing for this search. (frontend implementation didn't catch up and we postponed frontend feature to next milestone) link for related commit	#132	--

• It was a challenge for me to working with a team which composed of 10 people in implementation, I've never do this before.
• I realized that version control is more complicated than I think and requires writing code modular to other people. Because its critical having less conflict between branch while merging them.
• Login and Signup persistance is also a deal for me through implementation process.

Contribution	Issue Link	Wiki Link
I have initialized the mobile app project with React Native. I've used create-expo-epp tool to do that.	#115	--
I've scheduled some meetings with Ahmet and Orhan for determining the organization plan and determined what to do for everyone.	#120	--
I have determined what components we need to design and distributed them among the mobile app team (Ahmet and Orhan)	#129	--
I've written the button components that will be used across the app	#129	--
I've written the text styles that is common for most of the app using StyleSheet	#129	--
I tried do deploy the backend to the digitalocean server. It didn't work but the experience I had was used when Fırat deployed it.	--	--
I'he written login and signup pages on mobile app using React Native. I've used Fetch API to send HTTP requests.	#137	--
I've written the game card component that will be used accross the app.	#138	--
I solved some dockerization problems in the backend side of the project.	--	--
I've written the installation and development documentation for the mobile app team.	#128	--
I've written some of the seqquence diagrams	#106	Sequence Diagrams

• Although I mostly written the mobile app side of the project, because we had some lack of strength on the backend side, I needed to learn the django framework too to help the backend team. I couldn't add anything new, but I've helped them to fix some bugs.
• Since I was responsible for the deployment of the backend side, I haven't sleep a day to deploy it. I tried many thing to deploy, but because the lack of experience, I couldn't solve the bugs that I've encountered.

Contribution	Issue Link	Wiki Link
I reviewed and updated Scenario 4 according to feedbacks from my teammates and now it is consistent with the current requirements of the project.	#111	Scenario 4
I attended a meeting with Işıl and Taha to discuss about the plan and work share about sequence diagrams, I also took notes in the meeting, than I created 14 sequence diagrams according to the project requirements and other diagrams.	#106	Sequence Diagrams
I took notes in the front-end team meeting and added that notes to wiki	#124	Frontend Meeting #1
I reviewed and re-organized the Responsibility Assignment Matrix (RAM) with Soner. I added the responsibilities after Milestone 1 by checking the issues, meeting notes and off-meeting discussions to extract all works properly.	#109	RAM
I created Docker files for frontend and also updated the Docker compose file written by Işıl accordingly to make it work for frontend part	#133 and #152	--

• I had difficulties in figuring out for what situations I should make sequence diagrams and what kind of structure they should have.
• Since I did not have any experience or knowledge in software development, I had a hard time in the coding part. Although I tried to learn through various researches, I could not reach a sufficient level and therefore I let my friends down a little in the implementation part. I did various research about React, Docker, DigitalOcean, HTML, CSS and web development in general, however, I could only use Docker properly in our project.