1. Introduction and Goals
1.1. Requirements Overview
Nowadays, all the average social platforms for hikers are centralized and not totally secure services. With Viade, we present a proyect that consists of a decentralized routes management system developed following solid specifications.
The main requirements are:
-
The system will be based on a decentralized architecture where data storage is separated from the app.
-
Users can store their routes in their own pods.
-
Users can view the routes stored on a map.
-
The app will allow a user to share pictures, videos or information about a route with other friends.
-
A user can get notifications when some friend shares a route with him.
-
Users can have groups of friends with whom they may want to share a route
-
It should be possible to view routes loaded by users that are using a different app, so interoperability with other route management systems should be taken into account.
The objective of Viade is to give users a platform where they can share their taste and opinions about the routes they take, in a way that they can be sure all their data will be secure.
1.2. Developers:
Their contributions have make this project posible
1.3. Quality Goals
Goal | Description |
---|---|
Usability |
All users must be able to use the application with no difficulties. Therefore, the app will be intuitive and will have a user-friendly interface. |
Interoperability |
All the system should allow the users to interact with other applications that use the same standard. |
Performance |
The service should run fluidly, with no problems or restrictions that affect to its performance efficiency. |
Availability |
The app should always work whevener the user has Internet connection and the server is available. |
1.4. Stakeholders
Role/Name | Description | Expectations |
---|---|---|
Teachers |
They mark the developers work during the project and give considerations about how it will be done |
A well-formed application, accomplishing the requirements that were proposed. |
Developers |
The workforce of this project will develop the main system while understanding the constraints and requests of the client. |
End with a good, usable, stable application, that represents the efforts we put during the project. |
End Users |
People who will use the final application. The system must suit the main goals for the users to have the best experience. |
Have an intuitive, fluid and easy use of the Viade system. |
SOLID Devs |
They provide the main technology in which the application is based |
They are interested in the best results possible of the project, as any work could be helpful as feedback of the SOLID technology. |
2. Architecture Constraints
Limitation | Explanation |
---|---|
Time |
The time to devote to the project itself and learning about the new tecnologies is limited to the duration of the course. |
Licenses |
We have limited resources, and some of the licenses that could be interesting to try are not included in the ones provided by our studen accounts. |
Use of React Framework |
The use of this JavaScript framework is a requirement of the project |
Solid |
As part of the decentralized nature of this project |
Arc42 |
It is used for the documentation |
GitHub |
Where our project will be allocate and the team will coordinate |
3. System Scope and Context
3.1. Business Context
Viade´s main goal is to give the ability to store, visualize and be shared to the routes withou storing the actual data, which is kept by the users.
The public target for the applications is all types of users, but especially non-technical users. The application will allow the user to store and visualize their routes in a map.
The users will be able to communicate among them by sharing routes, pictures or videos. The interaction can be between two individuals or multiple, by creating groups of friends. Whenever a user shares content with another one, the target receives a notification.
The application is decentralize, the application and the data storage are separated, being this last one owned and stored by the user. As the application will support interoperability, our users will be able to use the routes and other data in different applications with a similar functionality.
3.2. Technical Context
The main idea is to separate the data storage from the rest of the app, so each user will be able to store its data. The communication between the different users and the data sharing will be managed by the application itself.
To achieve this, we follow the SOLID specifications as it ensures that our application is decentralized. Each user will be able to store its data in their own POD and grant the applications access to just certain type of data. With SOLID users can use the data of the routes in other applications that also use that kind of data.
Javascript is going to be used as the programming language, since we are going to make use of the framework React, which makes it easier to develop interactive and attractive graphic interfaces, which is key to obtain a usable interface.
4. Solution Strategy
4.1. Design Decisions
For developing Viade we will be following the next strategy (the necessary reasoning of our decisions is explained in section 9):
-
Data Storage: Solid.
-
Programming Language: JavaScript.
-
Environment: NodeJS.
-
Continuous Integration and Testing: Travis, Codecov, Codacy, Jest.
4.1.1. Libraries
-
Main library: React.
-
POD access: Solid-File-Client.
-
Authenticate users: Solid-Auth-Client.
-
Map display: Leaflet.
-
Elevation graphics display: Victory.
-
Interface components: Material Ui.
-
File name generation: uuid.
4.1.2. Interoperability
We are based int the route specification of viade spec, which uses jsonld, as well as the folder organization.
4.2. Quality Goals
Because of the participation in the Inrupt challenge, we will follow the Solid project principles:
-
Freedom to decide where the data is stored.
-
No change when switching between apps (modular design).
-
Reuse of data.
Basic usability goals:
-
Uncomplicated interface (visual route interface).
-
Feedback for interactions between users.
-
Portable to mobile devices (optional).
4.3. Organizational Decisions
We have agreed that the best way for developing Viade is following Scrum.
Functionality will be developed incrementally and at the end of every sprint (three weeks long) we will have working software.
5. Building Block View
5.1. Level 1
In this first level we take a look on viade’s parts.
These are react components, they show the interface and interact with the user. The components not only encapsulates parts of the interface, but also funcionalities.
They manage the interaction with the pod and translates the data.
Since solid slows down when it needs to retrieve a lot of data we decided to implement a small cache that temporaly stores the routes whithin the session.
Even though they are not reprresented in the diagram, they are clases that represent data. These makes that makes the file format of the routes independent from the rest of the aplication. The interface components and the cache deals with the Route entity and others, instead of dealing with the files directly.
5.2. Level 2
Thie second block is a closer look into the handlers.
It coordinates the interaction between the information retrieved from the pod and its tranlation into entities.
It deals with getting and uploading files into the pod.
They translate the files from the pod.
5.3. Overview
These would be and example of the diferent parts interacting when uploading a route.
6. Runtime View
In this section, some use case scenarios will be described to indicate concrete behaviour of the application to a certain interaction.
This segment will be in continuous development.
6.1. Login
This is the runtime view on how to log in viade.
6.2. Create route
This is the runtime view on how to create a route in viade.
6.3. See routes
This is the runtime view on how to visualize a route in viade.
7. Deployment View
7.1. Infrastructure Level 1
Viade is a browser application, which means that it only requires:
-
Solid’s server: where the user’s pod (and all its data) is stored.
-
GitHub Pages server: the web hosting service where viade is deployed.
-
Any web browser: we recommend using Chrome or Firefox because they are the ones used during development.
8. Cross-cutting Concepts
8.1. Routes
The information stored, and showed in our application will be mostly about routes.
A route is a logic entity, independent from the format in which it is stored and the attributes that it contains, that represent a trajectory formed by different points on the real world.
Routes can be stored and loaded from the Pod of each user independently of which application has created them. That is because, thanks to the ViadeSpec, we have defined an specification that grants interoperability with other route management systems.
Routes are shown to the user through two different interfaces: one where they are listed with the map and the most important data about them, and the other one with more specific data (such as images) that the user can see when accesing the routes details.
9. Design Decisions
We talked about the decisions we have made at section four (Solution Strategy), but in this part of the documentation we will explain the advantages of them, as well as their disadvantages.
Decisions | Advantages | Disadvantages |
---|---|---|
JavaScript |
Provides more resources in Solid. |
Not a programming language we are used to. |
Solid |
Protects user’s privacy. Develop without harvesting massive amounts of data. |
The scarce sources of documentation. The low performance retrieving data. |
React |
Efficient update and render of the UI. |
Coupling of the logic and the interface. |
NodeJS |
Fast, efficient and nonblocking. |
Uses only JavaScript. |
Github |
The version-controll system we are used to. Issue tracker, wiki, etc. |
Conflits may arise. |
10. Quality Requirements
10.1. Quality Tree
10.2. Quality Scenarios
We will contemplate two kind of scenarios: * Usage scenarios describe the reaction of Viade to a stimulus. * Change scenarios indicate whether a modification of the system is done.
ref | Quality attribute | Quality scenario | priority |
---|---|---|---|
1 |
Interoperability |
A user can share routes with users that use other applications. |
High |
2 |
Usability |
A user must be able to use the application in an intuitive way. |
High |
3 |
Performance |
The system must be able to follow in realtime the route a user is doing. |
Medium |
4 |
Performance |
When finished, a route must be shared within 30 seconds with the user’s friends. |
High |
5 |
Availability |
A user can search all the routes his friends have shared with him in any moment. |
Medium |
6 |
Availability |
If a user doesn’t have Internet connection when doing a route, he will be able to upload the route when connection is restored. |
Low |
7 |
Security |
The application must prevent any user’s data leak. |
Low |
8 |
Scalability |
If number of users increase, the application’s performance must be the same. |
Medium |
9 |
Portability |
The system should be easy to port to another platform in a short period of time. |
Low |
10 |
Performance |
Load times must be under 1 second. |
High |
11. Risks and Technical Debts
RISK |
DETAILS |
* The users are not able to interact with the application in an easy way. |
Sometimes, as a developer is easy to interact with your own application, but keeping in mind that non-technical users will interact with it is important to make a good product. |
* Poor performance of the application. |
The application may receive a lot of requests at the same time. It is necessary to apply techniques that increase effectively the performance of the application. |
* Bad usage of the proposed technologies. |
The usage of solid or react is completely new for the development team. Taking a look and practcing with these technologies can decrease the risk of making mistakes while using them. |
* Communication problems between the members of the development team. |
An efficient way of ensuring that the team works as expected is to distribute the tasks equitatively, expose any problem that a member may have and collaborate to solve all doubts that appear in the development process. |
12. Glossary
Term | Definition | More Information |
---|---|---|
Solid |
Tim Berners-Lee’s project to to create a decentralized web where users data is separated from application and services. |
|
Pods |
Personal Online DataStore, accessible from the web. Where the information about the user is stored. |
|
ViadeSpec |
Linked Data specification developed during the course of Software Architecture for making our apps interoperable. |
|
React |
A JavaScript library for creating user interfaces. |
|
Json-LD |
A lightweight Linked Data format that is easy for humans to read and write. |
|
Linked Data |
Structured data which is interlinked with other data so it becomes more useful through semantic queries. |
|
Inrupt |
Team of developers, designers, and business people who have been working to ensure Solid is becoming robust, feature-rich, and increasingly ready for wide-scale adoption. |
|
Scrum |
Framework for effective team collaboration on complex products |
About arc42
arc42, the Template for documentation of software and system architecture.
By Dr. Gernot Starke, Dr. Peter Hruschka and contributors.
Template Revision: 7.0 EN (based on asciidoc), January 2017
© We acknowledge that this document uses material from the arc 42 architecture template, http://www.arc42.de. Created by Dr. Peter Hruschka & Dr. Gernot Starke.