Tools for program understanding and reverse-engineering of mobile application

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).;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. 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. (Abstract shortened by UMI.).