程序代写代做代考 android javascript IOS flex Java database Microsoft Word – architectural design.docx

Microsoft Word – architectural design.docx

Architectural Design – Group 14 (coursem8)

Technologies used:

• JSP/HMTL/CSS for front end implementation.

• Gradle framework for automated builds.

• Cucumber for testing.

• Bootstrap

• MySQL to store usernames

The use of JSP/HTML/CSS

By utilising Java Server Pages (JSPs) to store our HTML and XML code, we will be able to

provide dynamic web pages. The main difference with JSP pages is that they employ the

Java programming language as suggested by their name. This results in the need to use it

with a compatible servlet container which is provided by the Gradle framework; the core of

our project.

The main benefit of deploying JSP pages is that they provide a clear separation between

presentation logic and business logic. This not only reduces the workload for the main

programmer (architect) but it also means you can delegate the programming tasks easier.

For example, instead of having programmers who are responsible for the entirety of the

project, we have split the role into two categories; back-end and front end.

Moreover, JSP accepts multiple languages such as JavaScript, VBScript and Perl. This strong

compatibility allows the programmer to provide more functions which make use of the

aforementioned languages on the website thus resulting in a great experience for users.

Gradle framework

Gradle uses a directed graph which automatically decides the order for running the

tasks, this will help the structure of the project and this is the exact reason as to why we

will be using this framework in our project. This will reduce the time that the architect

and support programmers will reduce and will allow them to concentrate more on the

development of the programme.

Cucumber for testing

Cucumber testing is an automated testing which is based on Gherkin Scenarios. We will

use cucumber to test the functions that we are implementing. During this worksheet,

we are required to implement 3 functions we have selected are; log in/ log out,

password recovery and registration. The use of cucumber in the project going forward

from this point will be to ensure that future functions that will be implemented can be

without bugs and errors in the code.

Bootstrap

Bootstrap offers a great number of already implemented features like global CSS

settings with built-in components and extensible classes. It would be easier for us to

implement the actual software because front end programmers will have less work to

do. A major advantage of the Bootstrap framework is its ability to streamline

responsiveness; by making minimal design decisions, our web application will look

scaled for every type of mobile device. The significance of this is it saves time as there

would be no need to develop a native iOS or Android app.

Architectural Diagram

External API’s to be used:

Open Street Map:

Open Street Map will provide the project with map services, e.g. navigation as one of the

functions requires us to allow the lecturer to be able to locate leaners via a GPS location.

By using Open Street Map the lecturer will be able to clearly see where to learner is on the

campus. Open Street Map will give the programming team an easy way to implement and

embed onto of the API this will give us full embedding into the system without any

complications.

Security Strategy

Adding a persistence layer to the database using JPI’s will help store users and control

permissions in a much more efficient way; who views what and manages what data in

the database. There will be runtime for when a user does not use the account for a

certain period to avoid someone using another person’s account on the same device.

When resetting password, the system will not allow the same password in case

someone cracked the first one.

When a user creates an account, they need to provide email address to allow safe

communication between the system and the user. An activation link will be sent to the

users student email to confirm their identity, to which the user will provide password if

not account will be inactive. If users enter a wrong password a few times, the account

should be locked until the password has been reset. A user should be able to report any

suspicious act on the account to the administrator. Passwords will need to be complex.

For example, a strong password should consist of a combination of uppercase and

lowercase letter, numbers and special symbols.

Performance Strategy

We are expecting there to be a small number of users at first for the system while we

embed the system gradually embedding it in everyday use for learners and lecturers,

but the use will become greater throughout this period as more courses will integrate

into the system.

We will ensure the performance of the system is maintained by continuously looking at

the average request response time; for example, we will look at how long it is taking

users to log in at the start of the integration when there is only one or two courses on

the software compared to the length of time taken to log in every time more users are

added. This will also give us an understanding of how fast the software is running and

dealing with requests as we will be measuring the tests with seconds giving us a clear

indication of how fast the software is dealing with requests.

Software Design Patterns

Design patterns are used to implement code in a well-known format this will give

support programmers and other group members working on the code the best chance

of understanding the code written, this makes maintenance of the software a lot easier.

We will be using creational patterns this gives us the ability to program more flexibility

in deciding which objects need to be created in each situation, We will be looking to use

singleton creation pattern this will give us the ability to create a simple design pattern

the reason for this is that restricts the instantiation of a class to one object. Another

creational pattern we will consider using is the abstract factory design pattern this

design pattern would give us the ability to create dependent objects without requiring

their concrete classes.