Powered by Microsoft's Spot Market Engine
Accurate Indoor Positioning which precisely shows your location anywhere inside a building
Uses beacons for accurate triangulation. Beacons are placed in various locations inside a store
The app navigates you to the precise location of an object you want to buy
Mail: cosmin.bresug.15@ucl.ac.uk
Role: Team Leader, Client Laison, UI/UX Designer
Mail: tudor.nica.15@ucl.ac.uk
Role: Researcher, Programmer
Mail: thomas.yenbamroong.15@ucl.ac.uk
Role: Tester, Report Editor
As part of the UCL’s COMP204P and COMP205P module, all students, in teams, are required to develop a software specifically for the needs of clients assigned by the department. Our team happened to have a client from Microsoft who aspires to improve the current shopping experience through the utilisation of technologies. Beacons were chosen as the mean to transmit product information to the user’s mobile devices.
Our project is part of the bigger Microsoft Spot Market Engine project whose ultimate goal is to improve the whole shopping experience right before customers even think about making a purchase. Our part is focused on the customer experience within the stores rather than outside. The main responsibility is to help ease, once customers are brought to a store, the difficulty in finding an item of interest of that store and try to make the experience as seamless as possible. We regularly met up with the client to ensure the alignment of the project with the requirements and we got the full support of Microsoft when necessary.
Our team luckily got assigned the client Tim Gregson who has been working at Microsoft for over 10 years now. He has almost four decades of experience in the IT industry ranging from mainframe computer operations to systems design and development. Moreover, he used to work as the CIO for an innovative local authority before his time at Microsoft.
At Microsoft, he has been working directly with customers in a wide range of sectors like the retail, financial, transportation and many more sectors. He is currently Microsoft Services CTO for Local and Regional Government and is now leading the Microsoft CityNext Smart City project in England.
According to a study, many issues can arise throughout the whole customer journey which if not tackled properly can drive a great number of customers away. One problem that many shoppers have encountered is they tend to have a hard time finding an item especially in large-size stores.
As a result, the project is focused on such hardship to find an item in any given store. The way we tackled this problem was through the introduction of our own version of indoor positioning system (IDS). Technical details of how we achieved this can be found in later sections.
Requirements gathering is a crucial part of all projects and our project is no exception. We took it very seriously to fully understand what the client needed before we started any development. Also, we realised that these requirements would probably change as the project advanced, so we established very concrete means of communicating with the client right at the beginning of the process.
The entire first few weeks of the project were dedicated to the requirements. We had a number of meetings with the client before we went on to put everything together into the paper. It was inevitable that the client would come up with a number of things he wanted to be in the final project but we knew that we were limited to only a few of them. So what we did was to prioritized the requirements in the order of their importance, as a mean to guarantee that both parties are on the page in which we could refer back whenever necessary, and this also gave us a clear sense of focus. This was done through the MosCow analysis depicted below.
Platform where the retailers can:
- Input the maps of stores.
- Customise the beacons’ locations.
User application that will:
- Display the map of the store.
- Track the user’s location and display it on the screen.
- Inform the user of the item’s location in terms of corresponding zone.
For retailers:
- Methodology to split a store into zones with unique numbers assigned to each zone.
- Possibility to specify the id of each beacon.
- Ability to specify the real size of the store to scale the map.
- Possibility to see if the beacons radius' overlay each other and cover the store.
For users:
- The zone (on the map) of desirable item highlighted.
- Options to find other items in the store during the middle of app usage.
- List of items that the user can check.
For retailers:
- A web application that will allow the retailers to input the details of the stores such as stock availability.
- Possibility to change the radius of each beacon based on the brand and signal.
- Application to detect beacons and find the exact beacon IDs.
For users:
- Notify the users as they enter the store in which the item of interest is in stock.
- Tool to manually draw a map.
- An integration of the application with the Spot Market Engine and the databases of inputted stores.
- Precise location of items inside a zone.
Operating Systems
In terms of operating systems, we researched operating systems that mobile phones normally use. Therefore, we have reached the conclusion that the platforms most normally used are Android, iOS and Windows Phone. In order to target all of these platforms at the same time, without needing to develop individually for each of them, we decided to use Xamarin as a framework (at the suggestion of our client as well). Moreover, the previous Spot Market project was also done in Xamarin so it is important for us to work in the same environment.
Programming Languages
In order to be able to develop for Xamarin, we needed to learn C# and accommodate to the framework's syntax. Therefore, at the suggestion of Yun Fu, we have studied a book called "Xamarin Cross-platform Application Development - Second Edition" by Jonathan Peppers. We have successfully studied and understood the requirements for the project by trying out the examples in the book.
Libraries and APIs
In order to make the project we required beacons. The ones we decided to get were Estimote beacons. Not only were they compatible with a library called AltSpace which tries to unify all beacons under one easy-to-control library, but also they have their own API. For both of these we researched the documentation in order to understand how they work. Finally, we decided to use the Estimote SDK as it allowed us more control over the beacons and better means of reading the signal.
Indoor positioning system
Indoor positioning system is a system that locates objects or people inside indoors using radio waves, magnetic fields, acoustic signals, or other sensory information collected by mobile devices. There are several commercial systems on the market, but there is no standard for the system.
Indoor positioning system uses different technologies, including distance measurement to nearby nodes with known positions (e.g. WiFi access points), magnetic positioning, dead reckoning. They constantly locate mobile devices and tags for devices to get sensed.
Despite a range of technologies we could choose from, the client specifically recommended beacons. As a result, our research was mainly focus on the bluetooth technology of beacons.
Bluetooth Technology
Bluetooth is a technology used to enable smart devices to communicate with each other wirelessly. Its design allows it to consume very low power as well as is based on low-cost transceiver microchips. Approximately, bluetooth communicates using radio waves with frequencies within the 2.4 GHz ISM frequency band. ISM frequency band is a frequency band that has been specifically reserved for industrial, scientific and medical devices by international agreement. The specification of bluetooth was internationally devised in 1994 and is now managed by the Bluetooth Special Interest Group (SIG). The technology can be split into three main categories according to its range. The listed range can vary from location to location, since the signals tend to be affected by propagation effects especially in an indoor environment. Type 3 is regarded ideal for indoor positioning system due to its relatively short range. However, most bluetooth devices are available in a form of the second class.
Such device can connect to up to seven other devices at the same time by setting up an ad-hoc network. Such networks may be set up automatically where the initiating device acts as a master to all other devices. A technique referred to as spread-spectrum frequency hopping is a method used by bluetooth to avoid any interferences among devices. With this method, a device will send out one of 79 randomly chosen frequencies, switching from one to another frequency 1600 times per second. As a result, it is highly unlikely that two devices will transmit signals on the same frequency and hence minimises the risk of interference.
In practice, a device must perform an inquiry to discover other devices which are in its range before a network can be set up. This process can take up to 11 seconds in one go. Subsequently, any discovered devices will send back information about itself like their names and addresses. The network can then be set up between devices that are within the master device’s range.
Beacons
Beacons or bluetooth beacons in the specific case are small radio transmitters that send out signals in a radius of 10-30 meters. The signals will get picked up by the user’s device via bluetooth. Given that the location of the beacon is known, the application then uses the signals previously received by the device to work out the accurate location of the user within the store. The project is largely based on the integration of beacons where great challenges lie.
Mathematical Modelling
Location will be worked out numerically by estimating signal propagation and calculating angles or distance. Inverse trigonometry will then be used to determine location of an object. In general, there are three main methods used in this, fingerprinting, triangulation and trilateration. Only the latter method, however, will be covered since it is the method that the client wanted us to implement in.
Trilateration
Because the user U is at a distance d1 from beacon B1, we know that the user is placed on the circle with the center marked by the B1’s position and with the radius d1.
(xu-xb1)^2+(yu-yb1)^2=d1^2
Where:
xu=x coordinate of U
yu=y coordinate of U
xb1=x coordinate of B1
yb1=y coordinate of B1
Similarly, U is also placed on the circle with the center in B2 and with the radius d2, so the user should be at one of the 2 intersections of these 2 circles. We now have a system of 2 quadratic equations, with 2 unknown variables (xu and yu):
(xu-xb1)^2+(yu-yb1)^2=d1^2
(xu-xb2)^2+(yu-yb2)^2=d2^2
Where:
xu=x coordinate of U
yu=y coordinate of U
xb1=x coordinate of B1
yb1=y coordinate of B1
xb2=x coordinate of B2
yb2=y coordinate of B2
This system has 2 possible solutions. We can use the distance between U and B3 to find the right solution (at which intersection U is).
References
http://tam.unige.ch/assets/documents/masters/bekkelien/Bekkelien_Master_Thesis.pdf
http://uk.businessinsider.com/beacons-and-ibeacons-create-a-new-market-2013-12
http://www.qrg.northwestern.edu/projects/vss/docs/navigation/1-what-is-triangulation.html
https://senion.com/indoor-positioning-system/
Interact with the prototype by clicking on the screen
In this project we have decided, after much research, to use Estimote Beacons.
They have a range of 70 meters, their battery lasts 2 to 5 years, they support both iBeacon and Eddystone beacon technologies and have built-in NFC and temperature sensors.
Also, a pack of 3 costs $60, meaning that the price of $20 for a high-end and powerful beacon is a good one compared to other retailers.
As we have used Xamarin as our mobile development framework, we used design patterns that Xamarin supported. Those are the following:
Model, View, Controller Pattern - pattern used in mobile development to separate UI, control of UI and functionality
Singleton Pattern - pattern that makes sure that every class has only one instance (for example, every activity in the mobile app has only one instance)
Async Pattern - pattern used when backend code can run too long and hold up the updating of UI (beacons triangulation in our case)
Prototype Pattern - pattern used to obtain an object by copying another (we used this for our Bitmap object)
Memento Pattern - pattern used to restore an object to its previous state (canvas object in our case)
List of tools that has helped us in the development process:
Facebook/Messenger - communication tool
Google Drive - file storage and sharing tool
Github - source control
Visual Studio Team Services - source control
Balsamiq - mockups design tool
Marvel - prototyping tool
Adobe Photoshop - screen creating for prototype
Sublime Text 2 - code editor used for retailer app
Google Chrome - browser for testing retailer app
Microsoft Azure - web hosting for retailer app
Visual Studio - IDE used for client app
Xamarin - framework for mobile development
Xtensio - persona making tool
StoryboardThat - storyboard making tool
Adobe Premiere Pro - video editing tool
Microsoft Office - document writing and chart creation tool
Smartphones - testing the client app
Estimote App - app with demoes for beacon distance
The idea of the application is very simple and straightforward, you use it to hunt down what you cannot find any gigantic stores by searching the product into the mobile application. The stores provide you with such information via our web application. The key approaches we used to implement the functionality can be listed as follows.
Client-side mobile app
Indoor positioning system: the system is built using beacons and a triangulation algorithm. Using a minimum of 3 beacons, we can determine the position of the user through mathematical calculations detailed in the research section.
Direct navigation: the users location is displayed on the map inside the app. Whenever they select an item they want, the zone that contains said item is highlighted on the map. This way, the user can easily navigate to the item in question.
Retailer-side web app
Retailers upload product and store information: through a web platform, the retailers are a ble to make a map following a few standards. After that, they are able to place beacons on the map and specify their IDs. The information is then used by the client app to display information for the store.
The store map divided into zones: when a retailer uploads a map of the store, he has to draw each zone using different colors. Then, the platform processes and recognizes the colors as different zones. This not only makes it easy to discern different zones, but also helps the user navigate through the store.
Index | Phase/Feature | Scenario | Result | App |
---|---|---|---|---|
1 | Tool for the retailers to import an image (map) and to make a point appear where the retailer clicks | Import an image into the tool, click on it and check whether the points get marked on the map or not. | Success | retailer |
2 | Function to store the points’ coordinates from the previous step and to draw them on the map | After doing the previous scenario, reload the map and check if the points are still marked correctly | Success | retailer |
3 | Function to assign specific beacons ids to the points from the previous phases | Assign an id to a point, reload the map and check if that point still has an id assigned to it. Replace the beacon id for that point, reload the map and check that it got saved | Success | retailer |
4 | Front end: Navigation screen (guiding user to the item’s location) which has these buttons (when pressed, display a specific message): • Navigate between different floors’ plans of the store • Show user position • Show target item position |
Press the buttons for switching between floor plans, showing user’s position and target item’s position, displaying specific messages when pressing each of the buttons | Success | user |
5 | Add the map and the points with the beacons on the navigation screen and implement the functionality of the buttons | With hardcoded user position and target item position, press the buttons for switching between floor plans, to show the user position and target item position and check that they are displayed correctly | Success | user |
6 | Function to check connection with the beacon | Turn a beacon on and check that the function returns true. Turn the beacon off, check that the function returns false | Success | user |
7 | Function to get the distance to specified beacon | Check the displayed distance while moving further and closer to a beacon | N/A | user |
8 | Trilateration using 3 specified beacons placed on the map from step 1 | Place 2 beacons at a distance of 1 meter from each other. Place another beacon not in the same line with the other 2. While moving, check the displayed coordinates (representing user’s position) | N/A | user |
9 | Function to convert meters to map units | Make one meter equal to 0.5, 10 and 25 map units, repeating the scenario from phase 8 for each one. | N/A | user |
10 | Function to draw where the user is on the map depending on the position of 3 specified beacons | Place 3 beacons in a room and specify their position on the map and move through the room, checking that the user’s position is updating correctly on the map | N/A | user |
11 | Function to calculate which 3 beacons to choose for triangulation (when there are more than 3 beacons available within the user’s range) | Place 6 beacons in a room and specify their position on the map and move through the room, checking that the position is calculated based on the closest 3 beacons’ positions | N/A | user |
12 | Function to detect when the user enters and exits the shop | Manually specify 2 beacons to detect when the user enters the shop. Place one of them at the ‘entrance’ of the shop, the other one at one meter into the shop. ‘Enter’ the shop and check if you receive a notification | N/A | user |
13 | Add function to detect the zones of the store to the tool from step 1 and 2 | Import an image (representing the map) and check if the zone are correctly detected: each color to be detected as a zone. | N/A | user |
14 | Function to get the target item and highlight its zone on the map | With a hardcoded target item’s zone, check if the zone is highlighted when pressing the ‘showing item’s position’ button in the navigation screen | N/A | user |
15 | Front end: Notification screen (when the user enters the shop) | ‘Enter’ a shop and check if you receive a notification with hardcoded details about a hardcoded item | N/A | user |
16 | Front end: Searching screen (when the user searches for an item other than the recommended ones) | Search for items (in a hardcoded items list) and, after selecting an item, check that it is displayed correctly on the map | N/A | user |
17 | Function to trigger all the events after the user enters the shop | ‘Enter’ the shop and check that the notification with the target items appear and the map shows the user and target item positions on the shop’s map | N/A | user |
18 | Function to stop all the events after the user exits the shop | ‘Exit’ the store and check that the map and the info about the target items disappear | N/A | user |
19 | Front end: Login screen | Try to login with a hard coded account. Log out. Try to log in with an account that doesn’t exist (you shouldn’t be allowed). | N/A | user |
20 | Website for the retailer to input the items available in his store | Input some items. Using the user app, search for an inputted item and check its position on the map | N/A | retailer |
21 | Integrate the tool from steps 1-3 with the website | Do scenarios from steps 1-3 using the website | N/A | retailer |
22 | Integrate both apps (for the retailers and for the customers) with Microsoft Spot Market engine | N/A | N/A | both |
Unit Testing
To ensure we were heading in the right direction and therefore the functionality required by the client was feasible, we had to carry out a number of tests at the end of each cycle. Since there were many different aspects to the software, we decided to apply unit testing to the project. By following the practice of unit testing, we isolated each component into the smallest units before carrying out a testing on each individual unit to ensure its correctness. We came up with a table of all units of the project (which can be seen on our project website) in which was used as the guidance when testing.
Unit testing allowed us to work with small components of software, so if there are problems we could detect and fix them without overly affecting the other units. Moreover, this provided some kind of documentation of the software, in which the team members could use as a tool to revisit unit’s features and ways to use them. This could also be useful for the client as well; he could use it to gain a better understanding of what each unit does.
However, the testing did present certain downfalls as well. It was a difficult decision for the team members to make on what component could be represented as a unit. Also, the testing required the team to constantly update the table as the client’s requirements varied.
Despite certain disadvantages, every team member agreed that this was unit testing was the best approach in terms of testing. It allowed us to work with smaller components of the system which in effect massively reduced the complexity that might have arose otherwise.
In order to do unit testing in Xamarin, we used xUnit, a framework which contains various ways of doing unit testing.
User Acceptance Testing
As we didn't previously work with Xamarin before and our project was important to be tested by multiple users, we decided to also use User Acceptance Testing as a means of testing. This can be divided into two groups: beta based on prototype we used to gather information from student colleagues and client feedback we continously received during the development process.
We made a beta that had limited functionality in order to easily gather information about errors. We asked our users to send feedback to us in order to improve the apps until the final submission. Overall, we tested our app with around 10 users and managed to identify a few number of bugs in the retailer app.
Moreover, during the development process we also gathered feedback from the client. Whenever we implemented something new, we showed our client at the next meeting we had. This was very useful as our client came with suggestions that made us realize other functionalities that we could implement and that were trivial in some cases. For example, our retailer app didn't allow users to add maps that used shapes other than rectangles. Our client suggested that a store might be triangular or circle-shaped. Thus, we implemented the zone detector to find zones that use different shapes.
Overall, the User Acceptance Testing helped us gather erros and suggestions for features from our users and client. We considered using a library to automate the testing in this case, called Xamarin.UITest, but ultimately we think getting feedback directly from users was more beneficial.
Compatibility Testing
One issue when developing for Android is the various number of mobile devices that use this operating system. There can be phones with different phone sizes or different Android Versions. Moreover, some phones even have their own UI software installed on top of Android. This results in a conflict in how a developed app looks like when deploying to multiple phones. For example, if, when developing, we use a small screen size(let's say 4") to make the UI, when we deploy to a larger screen (say 5"), the content will not scale automatically and will looks really small in comparison to the screen size developed for.
The best solution is to create UI screens for all screen ratios. Thus, each phone will acquire the components it needs for its own size.
We managed to test compatibility between phones using Xamarin Test Cloud. Xamarin Test Cloud is a powerful tool which lets an user to deploy his app to the cloud, where it is installed on multiple phones. Our client, Tim Gregson, mentioned that Xamarin Test Cloud actually uses real phones and not simulations of them. This is really useful as you can see how your application behaves on different phone sizes.
At first, our application did not look good and actually worked only for 4" screens. We managed to solve this easily, but it took some time to redesign the front end again for all versions. While we didn't have enough time to scale the content for tablets, we managed to make the app scalable for phones with screen sizes between 4"-6" which, ultimately, should be enough as most of the phone nowadays fit in this profile.
One more small issue that showed up while doing Compatibility Testing was the app not installing on some of the phones. We concluded that this is perfectly normal as we targetted Android SDK Level 16 as a minimum in order to make use of several newer features in Android. This means that a phone will need a minimum Android version of 4.1 (Android JellyBean).
Incomplete Features and Bugs:
Beacons tend to display wrong distance due to them not being accurate enough (bug)
User can be shown outside the map due to previous issue (bug)
Information below the map is currently useless as we do not do anything with it(incomplete feature)
By the end of the project, the amount of work we achieved was very satisfiable. We were able to hit most of our targets set at the beginning. It was largely due to a huge amount of time dedicated in the first time to fully understanding the needs of the client and hence getting them right in the first place. Doing this had allowed us to set very clear roadmap for the project and all we had to do was then following the plan.
After finishing the requirements and building the roadmap, the project next shifted to the development phase. We started off by thinking about how we wanted the software to look like. Every team member participated to brainstorm in order to optimise the user interface (UI) as well as the user experience (UX). While we were being very determined, we had to take into account what is and what is not possible to implement based on our knowledge as well. We built and showed the paper prototype (available on the website) to the client in December.
After the Christmas break, we came back to start making the prototype into reality. Half of the team was working on the retailer-side web application while the other was busy developing the client-side mobile application. We managed to complete the web app first due to the familiarity of the technologies used like JavaScript, HTML and CSS. Our focus then shifted to the trickier app development which involved unfamiliar technologies like Xamarin and beacons. Most of the development phase was dedicated to the mobile app which required lots of attention. The experience proved to be very challenging but we managed to complete the final version in the end.
However, we stumbled into many challenges along the way especially during the development phase. The client required us to use Xamarin as the development platform which none of us had been exposed to. It was a relatively new concept to all of us so there was a time when the project was going at a slower pace than what we would have liked it to. Another delay happened when we waited for the purchase of the beacons to be approved by the department. We could not carry on with the development and we had to wait without making much progress for the arrival of the beacons. Furthermore, the project continued on into the Easter break when we worked hard to finish the application.
To summarise everything we have done, we were able to successfully implement every feature as stated in the MosCow analysis. We also managed to complete the web application that allows the interaction with the retailer-side as well as some of the extra features within the client-side mobile application. Both of these were not requirements but were things that the client thought that would be good to have. By the end, we did not have enough time to implement the ‘Could have’ feature which was to integrate our software with the Spot Market Engine’s database.
Overall, we were all satisfied with the final outcome of the project though we could improve on certain things. For example, approximately two weeks were wasted on waiting for the beacons arrival. We should have better spent these two weeks on something else like carrying on working on the UI of the application. However, we were able to pull of all the “Must have” features, the integration with the database that we did not implement was not required so it did not greatly affect the project. In conclusion, we worked very well as a team; we kept the communications effective through both frequently-arranged team and client meetings, we structured the project plan very so the team was always focused and finally all of us put hearts and souls into the project.
We had a really good time working for Tim, he was both very helpful and friendly to work with. Working for Microsoft was one of the best experiences to have and we have learnt many things as a result. During the project, we had been exposed to the warm and friendly culture through Tim and hope to be able to work with or even for the company again in the future.
As mentioned earlier, there are certain things that could have been done to improve the overall capabilities of the application had there been more time. The two key things are an integration with the Spot Market Engine and creating a database for product information. These are the two things that the client raised during the meeting but did not require us to implement. As a result, we think that they would be what we would focus on if we had another 6 months. The client suggested we do not overcomplicate the project with databases in order for whoever picks up the project later to easily start working on it
Currently, the software is a standalone app meaning that it cannot communicate with any other applications within the Sport Market Engine project. Moreover, there is no database in place which can be used to keep record of any of the information that would be inputted by the real retailer users.
One thing that we would have liked to add as well would be a link between the retailer app and the client app. Currently, the retailer can input the beacon locations and select the zones on the map, but the actual map and beacon locations are not directly sent to the mobile app. Instead, we have to change them manually. We would have liked to add a screen which would let a user choose the store and display various maps based on that. However, our client is only interested in the indoor positioning system rather than small details like this.
Although we know we could have added additional features and improve the app a lot, we also consider that the purpose of the project has been achieved with the implementation of the indoor positioning system.
Date | Phase (Experimental Phases) | Achieved |
---|---|---|
31 Jan – 7 Feb | Phases 1-3 | Yes |
7 Feb – 14 Feb | Phases 4-7 | Yes |
14 Feb – 21 Feb | Phases 8-9 | Yes |
21 Feb – 28 Feb | Phases 10-12 | Yes |
28 Feb – 7 Mar | Phases 13-14 | Yes |
7 Mar – 14 Mar | Phases 15-19 | Yes |
14 Mar – 21 Mar | Phases 20-21 | Yes |
21 Mar – 28 Mar | Phase 22 | Yes |
28 Mar – 11 Apr | Finishing touches and final testing | Yes |
11 Apr – 25 Apr | Individual and Team Reports, Video, Presentation, Website | Yes |
As part of COMP204P and COMP205P, each student group is assigned a client who requires the team to develop a specific piece of software. We got assigned Tim Gregson from Microsoft who wanted us to continue working on the Spot Market engine from last year. The client’s requirements for our team were very simplified and open-ended; he initially wanted us to develop a software which utilises an indoor positioning system. The team realised that in order to develop a high-quality software productively in such circumstance, flexibility and effective communications were at heart of the project. We then went on the explore many different software development methodologies and extreme programming (XP) seemed to be the most promising one.
The fact that we only need to submit the project once means that we will not be able to retrieve the project to make any further improvements if the client is not satisfied with certain features. This then required us to apply short development cycles to the project rather than a long one. We kept the client updated of every cycle through regular meetings (around once every two weeks), bi-weekly reports and the project’s website. We informed the client of everything that was going on in terms of functionality, tools used and progress. This had allowed him to effectively and conveniently communicate any desires he may have regarding to project.
Also, we started off the project with a simple solution to the client’s request believing that extra features can be added in later stages which is the concept encouraged by XP. Goals for every cycle were set aimed at specific functionality. In the post-feedback development cycles, we then made modifications accordingly. Unit testing was used as mean to validate results for each cycle.
By following the practice of extreme programming, the client was allowed to make changes of requirements along the way at any stage of the project he may wish. Moreover, we worked very hard to ensure that we were within the client’s reach; we regularly kept the client up-to-date with every progress made in each development cycle through website and documentation.