| dc.description.abstract | Mobile software development is evolving rapidly. Software development includes computer programing, documenting, testing and bug fixing processes. These processes need a detail understanding of the application logic which often requires reverse-engineering their artifacts. My thesis identifies and addresses the following three problems in mobile software development, specifically in program understanding and reverse-engineering for mobile application development. (1) There is no graphical on-phone debugger. (2) The second problem is that mobile software programmers have to manually re-implement the conceptual screen drawings or sketches of graphical artists in code, which is cumbersome and expensive. (3) Companies try to “go mobile” (by developing mobile apps). To do that understanding the high level business of their current legacy software systems is necessary but challenging. To address these three challenges, this dissertation introduces the following three innovations. (1) GROPG is the first graphical on-phone debugger. GROPG makes debugging mobile apps more convenient and productive than existing text-based on-phone debuggers. (2) REMAUI is a mobile digital screenshot and sketch reverse-engineering tool. REMAUI makes developing mobile user interface code easier. (3) RengLaDom is a legacy application reverse-engineering tool. RengLaDom can infer domain concepts from legacy source code. Specifically, (1) debugging mobile phone applications is hard, as current debugging techniques either require multiple computing devices or do not support graphical debugging. To address this problem we present GROPG, the first graphical on-phone debugger. We implement GROPG for Android and perform a preliminary evaluation on third-party applications. Our experiments suggest that GROPG can lower the overall debugging time of a comparable text-based on-phone debugger by up to 2/3. (2) Second, when developing the user interface code of a mobile application, a big gap exists between the sketches and digital conceptual drawings of graphic artists and working user interface code. Currently, programmers bridge this gap manually, by re-implementing the sketches and drawings in code, which is cumbersome and expensive. To bridge this gap, this dissertation introduces the first technique to automatically reverse engineer mobile application user interfaces from UI sketches, digital conceptual drawings, or screenshots (REMAUI). In our experiments on third party inputs, REMAUI’s inferred runtime user interface hierarchies closely resembled the user interface runtime UI hierarchies of the applications that produced REMAUI’s inputs. Further, the resulting screenshots closely resembled REMAUI’s inputs and overall runtime was below one minute. (3) Finally, a promising approach to understanding the business functions implemented by a large-scale legacy application is to reverse engineer the full application code with all its complications into a high-level abstraction such as a design document that can focus exclusively on important domain concepts. Although much progress has been made, we encountered the following two problems. (a) Existing techniques often cannot distinguish between code that carries interesting domain concepts and code that merely provides low-level implementation services. (b) For an evaluation, given that design documents are typically not maintained throughout program development, how can we judge if the domain model inferred by a given technique is of a high quality? We address these problems by re-examining the notion of domain models in object-oriented development and encoding our understanding in a novel lightweight reverse engineering technique that pinpoints those program classes that likely carry domain concepts. We implement our techniques in a RengLaDom prototype tool for Java and compare how close our inferred domain models are to existing domain models. Given the lack of traditional domain models, we propose to use for such evaluation existing object-relational data persistence mappings (ORM), which map program classes to a relational database schema. The original application engineers carefully designed such mappings, consider them valuable, and maintain them as part of the application. After manually removing such OR mappings from open-source applications, our RengLaDom technique was able to reverse engineer domain models that are much closer to the original ORM domain models than the models produced by competing approaches, regardless of the particular ORM framework used. Additional experiments indicate that RengLaDom’s ability to infer better domain models extends to a variety of non-ORM applications. | |
