AWSM

Agile Web Migration for SMEs

Sebastian Heil and Martin Gaedke

Technische Universit

at Chemnitz, 09107 Chemnitz, Germany

Keywords:

Software Migration, Web Engineering, Agile Development.

Abstract:

Migrating legacy desktop to web applications is an important and challenging task for SME software companies.

Due to their limited resources, migration should be integrated in ongoing development processes. Existing

research in this area does not consider recent paradigm shifts in web development. Therefore, our work is

dedicated to supporting SME software providers in migrating to modern web applications while integrating this

into ongoing development. This paper outlines our idea and presents a roadmap towards achieving this goal.

1 INTRODUCTION

Driven by the high number of ways in which users

interact with recent web applications, changing user

expectations pose new challenges for existing non-web

software systems. Continuous evolution of technolo-

gies and fading away of support for obsolete technolo-

gies furthermore intensify the pressure to renew these

systems. As web browsers are becoming the stan-

dard interface for many applications, web applications

provide a solution to platform-dependence and deploy-

ment issues (Aversano et al., 2001). Existing software

systems have been developed over a long time and

contain valuable knowledge about models, rules and

solutions in their application domain. Thus, it is often

not practical to replace them by a newly developed

web application. Instead, it is necessary to transform

legacy into new software keeping the existing knowl-

edge. This is the objective of software migration.

Existing migration approaches are hardly feasible

for small and medium-sized enterprises (SMEs), can-

not be run in parallel to and combined with ongoing

agile development and do not consider the speciﬁcs of

web application development. Development teams of

SME software providers are occupied with develop-

ment and maintenance of existing applications. As the

resources are rather limited, there is no development

team available to exclusively dedicate to migration

(Horowitz, 1998). Agile development is widely em-

ployed, but there is no approach which allows migra-

tion to be integrated into day-to-day agile development

activities. Interactivity and ubiquitous mobile access

require migration towards web applications. However,

existing approaches do not consider web characteris-

tics such as distributedness, statelessness, hypermedia,

event-orientation, responsiveness etc. Also, recent ad-

vances in Web Engineering like re-use oriented com-

position approaches are not regarded.

Imagine e.g., a patient management system. This

software is run as desktop application at doctors’ of-

ﬁces. For adding interactivity like online appointment

scheduling, migration to web is required. However,

due to continuously changing regulations, SME de-

velopment teams are busy updating and maintaining

the system. This is where our approach for Agile web

migration for SMEs (AWSM) comes into play.

As there are many SME software providers with

legacy software and user expectations require transfor-

mation to modern web applications, enabling them to

successfully perform this migration within given con-

straints will impact the competitiveness of this sector.

We outline AWSM in Section 2. We position

our approach to related work in Section 3 and con-

clude the paper with a roadmap in Section 4.

2 THE AWSM APPROACH

As shown in Figure 1, AWSM contributes to four ar-

eas. For Requirements & Knowledge Discovery, we

propose a meta-model of knowledge, an annotation

platform and discovery tools. Migration Planning &

Implementation are supported by a component-based

target architecture, component repository and hybrid

web applications. Requirements & Knowledge Dis-

covery and Migration Planning & Implementation are

Heil, S. and Gaedke, M.

AWSM - Agile Web Migration for SMEs.

In Proceedings of the 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering (ENASE 2016), pages 189-194

ISBN: 978-989-758-189-2

189

Knowledge

Model

Annotation

Plattform

Enriched source

URL refs

Knowledge

Model

Knowledge

Model

Features

Knowledge entities

Knowledge

Model

Target

Architecture

Components

Placeholders

Knowledge

Model

Discovery

Tools

Crowd-based

AI-based

Knowledge

Model

Component

Repository

Default Comp.

Custom Comp.

Knowledge

Model

Hybrid Web

Applications

UI(X)

Communication

Requirements & Knowledge Discovery

Migration Planning & Implementation

Migration Management

Monitoring Dashboard Quality Visualisations

Management Integration

IDE integration

Migration Backlog

Test Generation

Agile Integration

p f

Figure 1: AWSM Overview.

iterative. Agile integration and migration management

intersect both areas. In Figure 1, a p denotes work in

progress and an f denotes future work.

Simple transformation approaches are not sufﬁ-

cient, as migrating to the web requires a fundamental

paradigm shift involving a distributed, multi-language

target environment. Thus, assisted re-development

taking into account these characteristics is required.

Here, the most important challenge is to avoid loosing

existing knowledge. Therefore, at this early stage we

focus on Requirements & Knowledge Discovery.

Requirements & Knowledge Discovery.

Legacy

system understanding is an art, but a necessary ﬁrst

step (Horowitz, 1998). To discover, document and

prepare the knowledge which is implicitly contained

in legacy source code for migration AWSM introduces

a knowledge model. Existing work, distinguishes three

types source code: presentation/user interface, ap-

plication logic and database access/persistence (Can-

fora et al., 2000; Horowitz, 1998; Ping et al., 2003).

OMG’s Knowledge Discovery Meta-Model (KDM)

speciﬁes a meta-model for software systems. The

source package of KDM describes source code ﬁles

and areas in the source code. However, KDM does

not provide a model for expressing the knowledge con-

tained in the source itself. This is too coarse-grain

and therefore we work on an ontology for knowledge

in source code. The knowledge ontology will be de-

scribed using OWL

and compatible with KDM.

Legacy system understanding is about understand-

ing what the software does and how the software does

it (Horowitz, 1998). Thus, our current draft distin-

http://www.omg.org/spec/KDM/1.3/

http://www.w3.org/TR/owl2-overview/

guishes between two types of code information: fea-

tures and knowledge entities. Features refer to code

which implements functional requirements that are di-

rectly visible to users. Knowledge entities comprise

the traditional categories of presentation, application

logic and persistence, but also business rules, conﬁg-

uration, deployment, algorithms and explanations in

comments.

Based on the knowledge ontology, the challenge

is to support developers to discover and document the

knowledge and to make it usable for migration. Com-

prehensive re-documentation approaches like (Corbi,

1989; Kazman et al., 2003) are neither feasible for

SMEs nor can they be integrated into day-to-day ag-

ile development activities. Based on (Rivero et al.,

2014), we introduce the concept of annotations to this

problem. Annotations can be applied as an additional

layer of description over the code. An annotation ex-

presses that a selected area of source code is related to

a feature or knowledge entity. Different code informa-

tion can be annotated independently and can overlap.

One code information can appear in several places in

the code, represented by several annotations. AWSM

supports developers by providing an annotation plat-

form which allows to enrich code with annotations.

Unlike traditional re-documentation approaches, our

web-based annotation platform provides a URL for

every annotation and knowledge entity. During re-

development, this enables developers to refer to the

knowledge, e.g. in emails, wikis, task descriptions etc.,

and jump to their deﬁnition and location in the source.

The discovered features deﬁne the requirements for re-

development. A screenshot of the annotation platform

can be seen in Figure 2.

ENASE 2016 - 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering

190

To lower effort for the annotation work, we are

currently investigating possibilities of executing this

classiﬁcation task by means of machine learning and

crowdsourcing. Our discovery tools are tested and

their effectiveness is evaluated in cooperation with our

industry partner, a software development SME.

Migration Planning & Implementation.

Migra-

tion planning deﬁnes the target architecture based

on components, focusing re-use and maintainability.

Components can combine all three application tiers,

but also represent only one such as user interface com-

ponents. Each component is described in terms of

features it provides.

The component repository contains a set of generic

components, such as displays, editors and lists of data

entities. If no suitable component is available, the ar-

chitecture uses a placeholder component requirements

description.

Hybrid web applications are an intermediate mi-

gration step. They consist of both newly implemented

components in HTML, CSS Javascript and also of

slightly adapted pieces of legacy code. Technologies

like Native Client

or Emscripten

allow to execute

legacy source code within the browser with only minor

changes. While migration to a ”pure” web application

is the objective, a hybrid web application can decrease

the initial hurdle to migrate.

Agile Integration.

The work of annotating a piece

of code can easily be done while working on this code.

When reading code during regular development or

maintenance activities and noticing valuable knowl-

edge, it can be annotated and thus be made explicit.

This is in line with the ”refactor as you touch code”

policy devised by many companies employing agile

development. To make this very easy for developers,

we will integrate our platform with an IDE.

Based on the annotated source, a migration backlog

consisting of migration stories is used as implemen-

tation plan. It is set up from implementation stories

for placeholder components and integration stories for

connecting the components as deﬁned in the target

architecture. To integrate with regular development

activities, migration stories are successively included

into iteration planning such as Scrum sprint backlogs.

To ensure functional equivalence we will apply test

generation approaches. From the re-discovered fea-

tures of the legacy system, acceptance tests for the

web-based system are created.

Migration Management

is important in enter-

prise contexts. We provide a dashboard to monitor the

progress of the migration. The annotated source allows

for analysis and visualization of structure and quality

http://gonacl.com/

https://github.com/kripken/emscripten

Figure 2: AWSM Annotation Platform.

issues. For instance, we display the interlacing of dif-

ferent features occurring in the same locations using

sankey and chord diagrams. Our migration platform

will be integrated with development management tools

like Team Foundation Server. A set of migration sto-

ries forming a migration package can then be moved

into the development management tool. This allows to

implement them like stories within the SME’s regular

development process.

A live demonstration of our migration tool can be

found at

3 RELATED WORK

There is some work in the area of web migration.

Code-oriented approaches like (Aversano et al., 2001)

analyse existing systems by call-graphs and decouple

architecture layers. Using a call-graph based decom-

position, the presentation layer is decoupled from the

legacy system, reverse engineered and redeveloped

with web technologies. Legacy Application logic and

database components are left unchanged and wrapped,

presentation is migrated to HTML/CSS. The authors

state that this can only be a short-term solution as it

does not improve structure and maintainability of the

system. It does not focus on improving end-user visi-

ble features. For instance, the resulting UI is very sim-

ilar to the legacy UI. It disregards current web design,

UIX and navigation patterns and responsiveness. Also,

nowadays web browsers are no longer restricted to

handling only presentation. Enabled by technologies

like Web Workers and client-side MVC frameworks,

more application logic is moved to the browser.

(Horowitz, 1998) describes web migration in three

steps: understanding the legacy software, designing

the architecture and testing and tuning. Distribution

of application logic to client and server is addressed.

In the architecture design, the decision of what to exe-

https://vsr.informatik.tu-chemnitz.de/demos/awsm

AWSM - Agile Web Migration for SMEs

191

cute on the server or client side is essential. Besides

UI, client side issues include how much application

logic is performed on the client and how the commu-

nication between client and server is achieved. The

resulting web application is based on HTML and Java

on the client side. The main focus is on communica-

tion in distributed applications via Corba, DCOM or

RMI. Since then, the web application environment has

changed. Browser-plugin-based technologies are van-

ishing. Components with communication via Corba,

DCOM or RMI are superseded by services and SOAP

or RESTful APIs.

Approaches like (Canfora et al., 2000) deal with

program decomposition as preliminary step for migra-

tion. Three types of components are distinguished:

user interface, application logic and database compo-

nents. For migration to a client-server architecture,

user interface components are migrated to the client,

database components to the server and application

logic can be on both. The condition is that the legacy

system is structured in distinct subroutines of the three

types and database is not calling UI. Like most pro-

gram decomposition algorithms, (Canfora et al., 2000)

exploits graph representations. The slicing algorithm

identiﬁes UI components based on control ﬂow in-

formation in a system graph colored according to the

types. An interactive tool allows software engineers to

mark application logic statements and extracts a new

subroutine for the server. An optional description of

the corresponding business rule can be added. Our ap-

proach distinguishes code at a higher granularity than

the three types found in most publications. For identi-

ﬁcation, we investigate human and machine learning

classiﬁcation, not only for UI. The interactive tool is

similar, but our annotation tool allows to reference

annotated code information by its own URL.

(Gu and Lago, 2010) presents a survey of service

identiﬁcation methods. Inputs can be knowledge at

enterprise level such as business processes, require-

ments, goals etc. or existing systems in terms of source

code, data etc. Only few approaches combine both.

The target output can be distinguished by service type.

Services are grouped into business or IT perspective

services. A wide range of strategies for service iden-

tiﬁcation exist. Among less common approaches are

component-based and UI-based methods, UI-based are

regarded as innovative. The knowledge re-discovery of

AWSM uses a combination of knowledge on enterprise

level and existing systems. To create the target archi-

tecture, AWSM employs a component-based strategy

in combination with UI-based.

(Ping et al., 2003) acknowledges the rapid changes

in web technologies and presents a transformation

framework for adapting existing web applications to

MVC web applications. The approach has three phases.

First database and presentation are separated by ex-

tracting db functionality and encapsulating it into java

beans using syntax analysis. Then, presentation is

transformed from HTML to JSP. In a last step, a

controller-centric architecture is achieved. The focus

is on database access encapsulation and control ﬂow

transformation whereas AWSM addresses all aspects.

This work starts from static HTML web pages and mi-

grates to MVC web applications in a J2EE context. By

contrast, AWSM support migration of non-web legacy

applications to web applications.

Even though the development of web applications

has changed signiﬁcantly – consider e.g. REST, client-

side MVC, mobile devices etc. – research has not

addressed this. Instead, the focus of web migration has

shifted. Recent areas of interest include migration to

service-oriented architecture (SOA) (Khadka et al.,

2013), migration to cloud environments (Krasteva

et al., 2013) and evolution of web systems (Kienle

and Distante, 2014). Surveys like (Khadka et al., 2013;

Razavian and Lago, 2010) provide an overview of re-

search in SOA migration. It comprises general phases

like legacy and target system understanding as well

as SOA speciﬁc ones such as service identiﬁcation.

Service identiﬁcation and identiﬁcation of service rich

areas is similar to component identiﬁcation in AWSM.

Open challenges in SOA migration include deﬁnition

of a common process model, automation, language in-

dependence and decomposability. While we can build

on the ﬁndings in general migration phases, migra-

tion towards interactive web applications differs. A

mayor difference lies in the impact of migration on

end users. Migration to SOA can be accomplished in

the backend without end users noticing. In contrast,

migrating legacy GUI applications towards interactive

web applications impacts the way in which end users

use the system.

Approaches like (Krasteva et al., 2013; Babar and

Chauhan, 2011) focus on migration to cloud environ-

ments. REMICS (Krasteva et al., 2013) proposes the

application of Model-Driven Modernization to the

Software-as-a-Service delivery model. As AWSM,

REMICS is based on OMG’s KDM(Object Manage-

ment Group, 2011). It focuses on migration process by

deﬁning seven activity areas such as requirements, re-

covery, migration and validation. Distinction between

requirements and recovery of knowledge - tradition-

ally combined as legacy analysis - can also be found

in AWSM. (Babar and Chauhan, 2011) reports on ex-

periences in migration of a web application to cloud.

It focuses on architecture modiﬁcations required by

the cloud environment. Two main aspects are stated.

Separation of persistence and business logic facilitates

ENASE 2016 - 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering

192

usage of cloud-provided storage services. Implementa-

tion of an orchestration layer is necessary when com-

ponents are distributed. Moreover, loose coupling of

components via HTTP-based APIs provides the possi-

bility to move components to different cloud providers.

There are several approaches for running legacy

C/C++ code in the browser. Google Native Client by

providing a runtime environment (Yee et al., 2009;

Donovan et al., 2011), Emscripten by compiling into

JavaScript subset asm.js (Zakai, 2011). WebAssembly

aims at specifying a common bytecode for the web. In

contrast to previous attempts, it seeks wide browser

support without requiring plugins. Building on experi-

ence from Native Client and asm.js, it is a promising

joint effort of all four major browser-providing compa-

nies (W3C WebAssembly Community Group, 2015).

These approaches bear good potential for use in mi-

gration as they allow to run legacy code in a web envi-

ronment. While this does not result in a true web ap-

plication, it can be an intermediate step and lower the

barrier to entry for migration. We are therefore evalu-

ating their migration capabilities and requirements.

Agile development has been applied to the soft-

ware migration domain. STDM (Abbattista et al.,

2009) combines a user-story-based iterative process

with automated acceptance testing. User stories and

story tests take the place of traditional requirements

documents. This improves sytem understanding and

is a starting point for the migration plan. Based on

user stories of the legacy system, acceptance tests for

legacy and new system are created. The legacy story

tests are iteratively migrated to the new system’s en-

vironment. AWSM builds on this work. We also use

annnotated features represented by user stories as a

starting point for agile migration Also, STDM does not

support feature discovery in legacy code. As stated by

the authors, STDM acceptance tests are only reusable

if legacy and target environment allow. While STDM

was tested on a small-scale Java to Java, Web to Web

migration, AWSM targets change in both program-

ming language and paradigm. Legacy acceptance tests

are therefore not reusable and are therefore left out

in favor of acceptance tests for the new system. In

(Krasteva et al., 2013), the authors describe an agile

extension of REMICS. The process is based on Type-

C Scrum and consists of several overlapping scrums

for REMICS activity areas. Also, inﬂuences from XP,

such as pair programming, are employed. In contrast

to AWSM, (Abbattista et al., 2009; Krasteva et al.,

2013) are agile migration methodologies that require

entire teams dedicated to migration. AWSM, however,

seeks to integrate migration work items into ongoing

agile development. (dos Santos et al., 2013) high-

lights the importance of visualizing technical debt for

communication within teams, with management. The

dashboard in our approach follows the same idea.

Approaches like (Rivero et al., 2014) demonstrate

how agile requirements engineering can be combined

with model-driven techniques. The idea is to build

on existing requirement artifacts, UI mockups in this

case, and add an additional layer of description by

enriching them with annotations. In AWSM we ap-

ply this idea to migration. The requirement artifact

is the source code, annotations are added to describe

migration-relevant properties. In (Rivero et al., 2014),

RESTful API prototypes are then generated from stan-

dard components. This is similar to AWSM, but our

components comprise all layers of the application.

4 CONCLUSIONS AND

ROADMAP

To conclude, existing migration approaches are not

feasible for SMEs, cannot be integrated with ongoing

agile development and do not address characteristics

of current web application development. Therefore,

we outlined the scope and detailed areas of work for

supporting SME software providers in migrating to

modern web applications while integrating this into

ongoing development. We brieﬂy reported on the cur-

rent state and presented the plan for future work.

In addition to the parts marked with p in Figure 1,

we are currently conducting a structured literature re-

view (SLR) of web migration approaches to provide a

systematic overview of existing approaches and chal-

lenges. After prototypical completion of the three

solution parts in requirements and knowledge discov-

ery, the next step on our roadmap is to evaluate the

tools with our industrial partner. We will observe how

the tools are used by the developers, identify problems

and iterate over the prototypes. Next step will be to

improve the agile integration and migration manage-

ment along with developers and product management.

Based on the feedback, we will adapt our solution ar-

chitecture and then address the parts marked with f in

Figure 1, in particular focusing on migration planning

and implementation.

ACKNOWLEDGEMENTS

This research was supported by the eHealth Research

Laboratory funded by medatixx GmbH & Co. KG.

AWSM - Agile Web Migration for SMEs

193

REFERENCES

Abbattista, F., Bianchi, A., and Lanubile, F. (2009). A

storytest-driven approach to the migration of legacy

systems. In Abrahamsson, P., Marchesi, M., and Mau-

rer, F., editors, Agile Processes in Software Engineer-

ing and Extreme Programming, volume 31 of Lecture

Notes in Business Information Processing, pages 149–

154. Springer Berlin Heidelberg.

Aversano, L., Canfora, G., Cimitile, A., and De Lucia, A.

(2001). Migrating legacy systems to the Web: an ex-

perience report. In Proceedings Fifth European Con-

ference on Software Maintenance and Reengineering,

pages 148–157. IEEE Comput. Soc.

Babar, M. A. and Chauhan, M. A. (2011). A tale of migra-

tion to cloud computing for sharing experiences and

observations. In Proceeding of the 2nd international

workshop on Software engineering for cloud comput-

ing - SECLOUD ’11, page 50, New York, New York,

USA. ACM Press.

Canfora, G., Cimitile, A., De Lucia, A., and Di Lucca, G. a.

(2000). Decomposing legacy programs: a ﬁrst step

towards migrating to client–server platforms. Journal

of Systems and Software, 54(2):99–110.

Corbi, T. (1989). Program understanding: Challenge for the

1990s. IBM Systems Journal, 28(2):294–306.

Donovan, A., Muth, R., Chen, B., and Sehr, D. (2011). Pnacl:

Portable native client executables.

dos Santos, P., Varella, A., Dantas, C., and Borges, D. (2013).

Visualizing and managing technical debt in agile de-

velopment: An experience report. In Baumeister, H.

and Weber, B., editors, Agile Processes in Software

Engineering and Extreme Programming, volume 149

of Lecture Notes in Business Information Processing,

pages 121–134. Springer Berlin Heidelberg.

Gu, Q. and Lago, P. (2010). Service Identiﬁcation Methods:

A Systematic Literature Review. In Nitto, E. D. and

Yahyapour, R., editors, Towards a Service-Based Inter-

net, volume LNCS 6481, pages 37–50. Springer Berlin

Heidelberg.

Horowitz, E. (1998). Migrating Software To The World

Wide Web. IEEE Software, 15(3):18–21.

Kazman, R., Brien, L. O., and Verhoef, C. (2003). Architec-

ture Reconstruction Guidelines, Third Edition. Techni-

cal Report November, Software Engineering Institute,

Carnegie Mellon University, Pittsburgh, PA.

Khadka, R., Saeidi, A., Idu, A., Hage, J., and Jansen, S.

(2013). Legacy to SOA Evolution: A Systematic Litera-

ture Review. In Ionita, A. D., Litoiu, M., and Lewis, G.,

editors, Migrating Legacy Applications: Challenges in

Service Oriented Architecture and Cloud Computing

Environments, chapter 3, pages 40–71. IGI Global.

Kienle, H. M. and Distante, D. (2014). Evolution of Web

Systems. In Mens, T., Serebrenik, A., and Cleve, A.,

editors, Evolving Software Systems, chapter 7, pages

201–228. Springer Berlin Heidelberg, 1 edition.

Krasteva, I., Stavru, S., and Ilieva, S. (2013). Agile Model-

Driven Modernization to the Service Cloud. In Pro-

ceedings of The Eighth International Conference on In-

ternet and Web Applications and Services (ICIW 2013),

pages 1–9, Rome, Italy. Xpert Publishing Services.

Object Management Group (2011). Architecture-Driven

Modernization: Knowledge Discovery Meta-Model

(KDM).

Ping, Y. P. Y., Kontogiannis, K., and Lau, T. (2003). Trans-

forming legacy Web applications to the MVC archi-

tecture. Eleventh Annual International Workshop on

Software Technology and Engineering Practice.

Razavian, M. and Lago, P. (2010). A Frame of Reference for

SOA Migration. In Di Nitto, E. and Yahyapour, R., edi-

tors, Towards a Service-Based Internet, volume LNCS

6481, pages 150–162. Springer Berlin Heidelberg.

Rivero, J. M., Heil, S., Grigera, J., Robles Luna, E., and

Gaedke, M. (2014). An extensible, model-driven and

end-user centric approach for api building. In Caste-

leyn, S., Rossi, G., and Winckler, M., editors, Web En-

gineering, volume 8541 of Lecture Notes in Computer

Science, pages 494–497. Springer Berlin Heidelberg.

W3C WebAssembly Community Group (2015). Webassem-

bly design: Minmal viable product.

Yee, B., Sehr, D., Dardyk, G., Chen, J. B., Muth, R., Or-

mandy, T., Okasaka, S., Narula, N., and Fullagar, N.

(2009). Native Client: A Sandbox for Portable, Un-

trusted x86 Native Code. In 2009 30th IEEE Sympo-

sium on Security and Privacy, pages 79–93. IEEE.

Zakai, A. (2011). Emscripten: an LLVM-to-JavaScript com-

piler. In Proceedings of the ACM international con-

ference companion on Object oriented programming

systems languages and applications companion, pages

301–312.

ENASE 2016 - 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering

194