Milestone 2 Report - bounswe/bounswe2023group3 GitHub Wiki

CmpE 352: Fundamentals of Software Engineering - Milestone 2 Report

Spring 2023 - Group 3

Contributors

Table of Contents

  1. Executive Summary
  1. Practice Application Deliverables
  2. Evaluation of Tools and Processes
  3. Challenges Faced During the Process
  4. Individual Contribution Reports

1. Executive Summary

1.1. Introduction

Our project is about a platform where users open “polls” for the other users (and themselves) to make predictions about the properties of events that will be settled in the future. Predictions are evaluated for their accuracy once the property they guess is settled, which then counts towards the rating of its user. Events are to be tagged/categorized, and consequently, users’ scores will also be tagged/categorized. Users may or may not be able to control the public availability of the collective estimate of the properties before they are settled, which is one of the many design decisions the team should make. Profile badges, achievements, and other social features are some others to be considered alongside the scores to hook the users in.

1.2. Project Status

We have already prepared requirements and related diagrams with the milesone 1. By that time, we have been working on practice app, in which we learned utilizing external APIs. We also get into creating APIs that supports GET and POST requests. Additionally, learning a version control system, dockerizing and deploying an app are parts of our learning perspectives.

The work done by us as follows:

  • We decided on using django since it was recommended by our teacher and some of our friends adviced it is easy to use. We made research for django for some time collaboratively, asking questions to each others.
  • We researched on some useful APIs that may be related to our project.
  • We implemented external API utilization and implementation.
  • By that time, we had been geting used to branching, pull requests, reviewing pull requests, merging branches, attaching issues to pull requests.
  • As time passes, we were completing our applications by adding tests and documenting our endpoints using swagger.
  • Since django is compatible with all those libraries (swagger, testing) and provides both front-end developing tools and back-end frameworks, it made our job very easy.
  • As we moving forward, some of our team-members worked on researching dockerization, account creation for AWS and deployment of application. And we documented our work on github/wiki.

1.3. Functionalities of the Practice Application

You can click here to see our application's home page. We implemented several functionalities there to which you can try out by clicking on them. you can see swagger documentation here.

1.3.1. commentVerification

this app provides the basic functionality to check if a comment is appropriate to be published. one endpoint of this app receives comments from users by a simple form and evaluates them using perspective api and saves the comment and evaluation result into database. other enpoint simply lists the history of the previously saved comment-evaluation result pairs.

1.3.2. countries

This application is designed to take country names and provide corresponding information. The details include the capital city, flag, subregion, population, and spoken language of the selected country. An additional feature allows users to add countries to a favorites list, remove them when desired, and also view the favorites list. The user interface is engaging,

1.3.3. weather_app

Weather Forecast and Air Quality Application has two main functionalities. It makes calls to the public API called “OpenWeatherAPI” to fetch weather and air quality data. If the user enters a valid city or country name, this application provides the weather forecast of 5 days in one endpoint and the air quality information in another endpoint. Air quality information includes the general condition of air corresponding to the air quality index and levels of some components in the atmosphere. Since this was a practice for our main project about prediction polls, choosing an API related to our main project was of an importance. The main reason of choosing to use this API is that its functionality may be useful while making while coming up with poll options or voting on polls under the weather tag. Another important point is that this application also shares a similar front-end design with our mock up template.

1.3.4. public_transport_app

You can check my individual contribution report for detailed information of my app here.

1.3.5. weatherApp

Weather application which takes an input city and returns some useful data and stores request on database. You can check the web application here You can check the individual report which explains the app and give further data here

1.3.6. university app

My app gives and saves about universities. You can check my individual contribution report for detailed information of my app here

1.4. Docker Instructions

You can check the dockerfile which was used to build the image by clicking here.

  • We used the following command to build the docker image: docker build --tag cmpe352group3/practice_app:1.0 .
  • After building the image we pushed the image to our dockerhub account: docker push cmpe352group3/practice_app:1.0
  • Then we pulled the image from the ec2 instance: sudo docker pull cmpe352group3/practice_app:1.0
  • Lastly we created a container and run it with the following command: sudo docker run --detach -p 8000:8000 cmpe352group3/practice_app:1.0

1.5. Related Meeting Notes

2. Practice Application Deliverables

3. Evaluation of Tools and Processes

Github

We used github to upload our complete tasks, create relevant issues, communicate with each other and revise our works. We have been managing our project through github, and with this platform we can easily track the status of each task related to the project, assign ourselves or other group members some tasks, or see the updates on the project. Github makes the process of developing a group project smoother, and helps us with its user friendly interface.

Discord

We used the server created for the course to communicate with the teaching assistant and with each other. Then we created our own group server and made different channels for different topics. Discord was used as the basis for our written communication, and we kept each other updated through here.

Whatsapp

We used Whatsapp mainly for fast communication, and to arrange the meeting times.

Django Rest Framework

Django and its additional features helped us launch our project in the real world. At this stage, we have gained important abilities such as using basic API functions and exchanging information in JSON format. Our knowledge of these matters is invaluable, as they are critical to many of today's web applications.

We learned to use and understand HTML, the heart of web design. Django has given us ample possibilities in this area on how to create web pages and add content. This gives us unlimited options to offer our users a more interactive and rich experience.

We've also gained experience using APIs. APIs enable our applications to interact with other systems and services. Gaining experience using Django has increased our capacity to connect with a wider network ecosystem.

SQLite

In our latest project, we found ourselves turning to SQLite as our choice of database. This wasn't just a random decision - SQLite has some solid benefits. Being a disk-based database, it's very lightweight and doesn't demand a dedicated server process to handle operations, which is fantastic. It just fits perfectly into projects like ours, where we value efficiency and simplicity.

SQLite became a real asset when we incorporated it into the Django web application framework we were using. It's almost as if they were designed to work together. SQLite facilitated easy and efficient database operations, significantly smoothing out the development process. This integration and subsequent ease of operations is a testament to the well-rounded capabilities of SQLite.

Swagger

Our API's functionality and use cases were effectively communicated through well-crafted and intuitive documentation, which greatly facilitated our understanding and utilization of the API. This resulted in a seamless user experience for both ourselves and potential users, ensuring efficient utilization of our API without compromising on its professionalism.

Docker

Docker has made significant contributions to this project. It has ensured portability of the application, packaging all dependencies and environment in one container, making it work seamlessly in any environment. In addition, it provides the opportunity for rapid deployment, enabling containers to be easily deployed to different servers or cloud environments. It has made test processes more efficient by enabling the rapid creation and demolition of test environments.

Amazon Web Services

As a result, we were able to deploy the application quickly and reliably, thanks to the services provided by AWS. We created and deployed server to run Docker image

4. Challenges Faced During the Process

There are several obstacles our group faced during the process of developing our practice application. We faced several challenges while developing our code in a single GitHub repository. One of the challenges was managing collaborative conflicts that arose as multiple team members made simultaneous changes to the codebase. Resolving these conflicts required careful coordination and effective communication among the related members. Additionally, maintaining code consistency was also hard, as different coding styles and formatting preferences among contributors made the code difficult to navigate. Another obstacle we encountered was branch management. Coordinating branch creation, merging, and deletion required clear communication and adherence to well-defined branch naming conventions. Despite these challenges, we successfully managed version control, code reviews, communication, and access permissions by establishing effective workflows and leveraging the collaborative features offered by GitHub.

Our group also encountered challenges while learning new tools like the Django framework and Docker. One significant challenge was the learning curve associated with understanding the framework's architecture and concepts. Django has a robust and comprehensive structure, which initially required us to invest time and effort in grasping its various components, such as models, views, and templates. Additionally, understanding the ORM (Object-Relational Mapping) and database integration posed a learning challenge, especially for those who were new to web development or working with databases. Another hurdle we faced was adapting to Django's conventions and best practices, as it has its own set of guidelines and patterns that deviate from general Python development. This required us to adjust our coding habits and understand the rationale behind Django's design choices. Despite these obstacles, our group embraced these challenges, collaborated effectively, sought resources and documentation, and ultimately gained proficiency in the Django framework.

5. Individual Contribution Reports