Reducing Double Maintenance for Web-based Application on a code- and logical level

Abstract

A problem within the mobile instustry today is creating third-party applications.
Generally developer teams have to develop the same application for several platforms and each platform uses a specific native language.

A result of this is that many applications both look and act similar; but
have different code bases and work very differently beneath the surface.
This is a double maintenance problem for developers that is hard to solve.
If a new feature is to be added, each team has to work on making the
same functionality work on each device.

Web technology, which refers to HTML5, CSS and JavaScript, have be-
come another possible solution in writing native code on some platforms.

If several platforms adopts the same technology, the development team
does not need the same in depth knowledge about each platform and thus
it will ease the developmet overall. But the big problem with double maintenance
still remains. Even if each application is written with the same technology,
if the teams still develop each application separately from each other,
very little is gained. But there might be a way to improve this.
When applications are written with the same technology, we think that there is
a high chance that a big propotion of the code is either the same, or could be the same.

We want to investigate if it is possible to combine the code base into a combined
one for platforms supporting native web applications. This should reduce or
possibly eliminate the double maintenance problem. But by combining the code
bases we believe that it will introduce another
problem, namely variants. Provided that we are able to combine the code
bases and that it creates variants. We will also investigate how to work
with the created variants. We also want to investigate if, and how we can
minimise the amount of platform specific code for communicating with
each platform’s hardware.

After analyzing the code, making iterative experiments along the way and
by researching different approaches on the code structure; we managed to
create an environment controlled by a python script that simulates one
combined code base, while it actually is separated into several different
ones. To support variants, a specific markup was introduced that allows
each platform to have its own sections of code.

Each platform has a native JavaScript API to access hardware and plat-
form specific features; these differ a lot in structure, usage and function.
By building an API that overlaps all platforms native API, we are able
to reduce the developers needs to interact with multiple APIs. After
studying, and experimenting with JavaScript API design conventions, we
produced an API, which through user testing, was found powerful and
easy to use. With this single API the development is easier to maintain,
contain fewer lines of code and reduces the workload on the developers.

• author: Gyllensvärd, Henrik and Welander, Niklas
• supervisor: Lars Bendix
• organization: Department of Computer Science
• course: EDA920 20141
• year: 2015
• type: H3 - Professional qualifications (4 Years - )
• subject: Technology and Engineering
• keywords: double maintenance, native application, variant, variants, combine code base
• report number: LU-CS-EX 2015-03
• ISSN: 1650-2884
• language: English
• id: 5323038
• date added to LUP: 2015-04-27 09:50:24
• date last changed: 2015-04-27 09:50:24