I'm interested in all things related to Software engineering in
general, with the long term aim of finding tools, techniques and methodologies
for increasing software development productivity. But in particular, I'm
interested in the following areas:
Mobile application development (Fragmentation problem in particular)
Software maintenance and evolution (effective clone management in particular)
Software reengineering and reuse (reuse via product line approach in particular)
Software engineering education (Designing project courses in particular)
Current theme: Addressing device fragmentation issues in mobile applications
Having to produce multiple versions of an application
to run on multiple devices increases the required
effort in many aspects of software development, such as implementation, testing,
certification (i.e., signing), delivering, and maintaining. This problem is
commonly – if not 100% correctly – called device fragmentation (DF). In the current state of the practice, it is almost impossible
to write a single version of a mobile application that can run on every (or at
least a majority of) mobile device
available.
Practitioners say that often one can end up having 400 or more different versions
(called Stock Keeping Units, or SKUs) for a single application [4]. At best, we
can only hope to minimize the number of versions that we need to serve an optimum number of
devices.
I'm currently at the stage of analyzing the device fragmentation problem to
identify promising research directions.
Click here
to see a document I compiled about device fragmentation.
Past work (in
which I'm still interested in...)
Exploiting Similarity Patterns in Software for Enhanced Genericity
and Maintainability
Leveraging repetition patterns in software to achieve productivity gains is
the holy grail of software reuse. A significant step in this direction is the
current trend towards patterns (design patterns, analysis patterns, etc.) and
frameworks (.NET, J2EE, etc.). These techniques epitomize the concept 'similar
solutions for similar problems', thereby reducing the effort required in software
development. However, such 'pattern-driven' software construction also results
in repeated patterns of similarity at analysis, architecture, design, and code
levels. These similarity patterns (aka clones) are detrimental to software maintenance.
Maintaining all clone instances consistently is a laborious and error-prone
task, further complicated by subtle differences between clone instances. Clones
also signify unused reuse opportunities that can be abstracted into reusable
artifacts, if appropriate reuse techniques are available. Reuse in this manner
is most useful in developing a software product line as most product line
members can be considered clones of each other. Effective 'clone management'
aims to improve over this status quo by mitigating the negative effective of
clones, and leveraging the future reuse potential signified by clones.
In this work I looked into gains achievable by effectively managing clones
in software systems, particularly in the rapidly growing area of Web Applications
(WAs). As evidenced by high level of cloning in existing software
[see publication], conventional methods are not enough to achieve generic,
clone-free software. Managing clones in Web applications is complicated by many
factors, notably the tendency to mix number of technologies when implementing
them (e.g., HTML, Java, Scripts, CSS, XML, etc.). My PhD research evaluated the approach that we call 'mixed strategy', for managing clones in the domain
of Web applications. Mixed strategy uses the meta-level generative technique
of XVCL to complement conventional
methods (such as generics, refactoring, design patterns, and features offered
by frameworks/platforms such as J2EE, .NET, Ruby on Rails).
These are some
areas I'm still interested in continuing work ...
Evaluating the effect of emerging technologies/trends on managing clones:
The technology landscape of Software Development changes rapidly. We need to
constantly identify emerging technologies and analyze how they affect the
problems posed by clones.
Tool support for clone management: We need to investigate
how modern software development tools (such as new and more powerful IDEs)
affect the problem of clone management.
The process aspect of managing clones,
particularly in a realistic commercial environment: Seamlessly integrating
clone management tools and techniques into prevalent software development
methodologies is indeed a significant step towards effective clone
management.