CSC301-Building Modern Software Solved

2.    Mobile application: “How do we build a mobile application that can easily be developed, tested, maintained, and distributed?” is the question leading this path. You can make an assumption about whether your application needs to run on Android, iOS, or both. But you must clarify that assumption in your report.

Next Steps
Your customer has chosen you as their trusted advisor and asked you to recommend a solution for their needs. You can start your research from the roadmaps we have seen during the lecture. Consider three main technologies to use for each part. For example, for the backend of your web application, you can look at Node, Python, or Go, or any other language you find interesting. For the frontend of your application, you can look at Vue, React, Angular, or any other language/framework. You will then need to compare the options you have chosen.

Considerations can include (but should not be limited to):

1.    Ease of development for you (e.g., you know Python but Go may be new to you)

2.    Maturity of the language/technology and the libraries available for integrations/UI

3.    The domains covered by the technology/language (e.g., Python also supports ML projects while Javascript can do both frontend and backend).

4.    Popularity of the language/technology. You can look at HackerRank 2020 Report, Stackoverflow 2019 Survey, or JetBrains Developer Ecosystem report.

5.    Performance, scale and speed of the solutions built with these technologies. 6. Any other criteria you think is important and needs to be considered

Your tech stack needs to include solutions for the following:

1.    Frontend technology

2.    Backend (web or mobile)

a. Needs to include Testing Infrastructure (e.g., PyUnit for Python unit testing). You don’t need to have comprehensive tests. One test is enough.

3.    Continuous Integration & Continuous Delivery (CI/CD)

4.    Database (we will talk about databases in one of future lectures in more depth)

Your setup needs to support:

1.    One development environment and a production environment.

2.    Automated deployment on merge at least to the development environment.

a.    You can use any of the CI/CD tools.  

b.    Your deployment needs to include running test(s)

Deployment
You are expected to make your applications available for your TA to see, test and grade (mobile and web). You will need to “deploy” your applications. We will use the word deploy loosely here meaning that you need to have your web application available via a url and find a way to share your mobile app with the TA (e.g., apks, expo, developer account sharing, video recording, etc).  
Web/Mobile 
Application 
Report  
__ /400  
40% 
100 points per comparison 
Deployed Application 
__ /400  
40% 
100 points per criteria 
Testing Availability 
__ /200  
20% 

Evaluation Criteria for Report (Web / Mobile)
You will be comparing three main technologies for each of your four web application components or each of your four mobile application components. Each of you comparison will be evaluated according to the evaluation criteria outlined below:  
 
All standard functionalities are present (i.e the application meets requirements)  

The workflows (e.g. going from feature or view to the next) can be executed 
Missing one or two standard functionalities 

Moving between features (e.g. workflow) isn’t fully functional but one can access each feature independently 
Missing three or four standard functionalities 

Little to no cohesion between features or application requires resetting between features 
Missing majority of standard functionalities  

No cohesion between features - it is impossible to move from one feature to another 
 
NO SOFTWARE 

PRODUCT 

EXISTS OR A 

CRITERIA IS 

COMPLETELY MISSING 
2 - The application’s UI is present and usable visual defects 

UI is 
visually/aesthetically pleasing 

UI is highly usable and incorporates design principles 
A UI was built 

UI is mostly cohesive and clear  
A UI was built for most features 

UI requires some testing or constant reference to documentation to use or understand 
Very few features contain a UI 

UI is very nonintuitive and without documentation testing would be 

difficult  
No UI was complete but some UI code 

exists 
3 - Testing infrastructure implemented 

Testing infrastructure set up  with one test case 
Test infrastructure is fully set up but is not functional (i.e. the test 
Test infrastructure is only partially completed 
No testing infrastructure but 
 
Testing infrastructure is comprehensive (beyond just unit tests)/ 

comprehensive/fully and easily extensible going beyond unit tests 
that can be run 

successfully 

Testing infrastructure can be adapted to develop further testing when 

expanding application functionality 

does not run 
successfully) 

Testing infrastructure cannot be adapted (or must be modified extensively) to develop more tests  
 
some code for testing exists 
Continuous Integration and Continuous Development setup 
Deployment goes all the way to production with every push to master running all infrastructure successfully with high-quality tests 
CI/CD is setup and runs everything successfully with every push 
CI/CD is set up  
CI/CD is fully set up but is not functional  
Team has evidence of unsuccessful but attempted CI/CD 

Evaluation Criteria for Testing Availability (Web & Mobile)

Product is available to a tester without setting it up on a 

developer machine 

Product deployment is easily repeatable  
Product deployment was completed manually with interventions at most or all stages of deployment (e.g adjusting multiple parameters, manual branch adjustments, directly accessing deployment environment) 
Product is deployed but cannot be accessed and requires team to present their work 
Team has evidence of attempted but unsuccessful deployment 
 
NO SOFTWARE 
PRODUCT 

EXISTS OR A 

CRITERIA IS 

COMPLETELY MISSING 

Instructions for testing are provided 

Above expectations 

in quality or creativity of instructions (e.g., highly detailed, video demonstrations, 

GIFs, etc.) 
Clear instructions are provided on how to use the application from the 

tester’s perspective  

Clear steps provided for using each feature that has been built  

Instructions can be executed as provided 
Instructions are provided for using the application, but some assumptions had to be made, or some ambiguity in 

instructions present 

Some of the instructions cannot be executed as provided 
Instructions are very unclear or 

ambiguous, and requires the tester to make many assumptions to use the application 

Some missing steps 

Provided instructions are insufficient for using the application from the tester’s perspective  

Steps not provided for using each feature that has been built, or 

many missing steps 

None of the instructions can be executed as provided