A document-like software visualization method for effective cognition of c-based software systems

It is clear that maintenance is a crucial and very costly process in a software life cycle. Nowadays there are a lot of software systems particularly legacy systems that are always maintained from time to time as new requirements arise. One important source to understand a software system before it is being maintained is through the documentation, particularly system documentation. Unfortunately, not all software systems developed or maintained are accompanied with their reliable and updated documents. In this case, source codes will be the only reliable source for programmers. A number of studies have been carried out in order to assist cognition based on source codes. One way is through tool automation via reverse engineering technique in which source codes will be parsed and the information extracted will be visualized using certain visualization methods. Most software visualization methods use graph as the main element to represent extracted software artifacts. Nevertheless, current methods tend to produce more complicated graphs and do not grant an explicit, document-like re-documentation environment. Hence, this thesis proposes a document-like software visualization method called DocLike Modularized Graph (DMG). The method is realized in a prototype tool named DocLike Viewer that targets on C-based software systems. The main contribution of the DMG method is to provide an explicit structural re-document mechanism in the software visualization tool. Besides, the DMG method provides more level of information abstractions via less complex graph that include inter-module dependencies, inter-program dependencies, procedural abstraction and also parameter passing. The DMG method was empirically evaluated based on the Goal/Question/Metric (GQM) paradigm and the findings depict that the method can improve productivity and quality in the aspect of cognition or program comprehension. A usability study was also conducted and DocLike Viewer had the most positive responses from the software practitioners

The use of additional information in problem-oriented learning environments

Self-directed learning with authentic and complex problems (problem-oriented learning) requires that learners observe their own learning and use additional information when it is appropriate – e.g. hypertextual information in computer-supported learning environments. Research results indicate that learners in problem-oriented learning environments often have difficulties using additional information adequately, and that they should be supported. Two studies with a computer-supported problem-oriented learning environment in the domain of medicine analyzed the effects of strategy instruction on the use of additional information and the quality of the problem representation. In study 1, an expert model was used for strategy instruction. Two groups were compared: one group with strategy modeling and one group without. Strategy modeling influenced the frequency of looked-up hypertextual information, but did not influence the quality of learners' problem representations. This could be explained by difficulties in applying the general hypertext information to the problem. In study 2, the additional information was presented in a more contextualized way as graphical representation of the case and its relevant concepts. Again, two groups were compared: one with a strategy instruction text and one without. Strategy instruction texts supported an adequate use of this graphical information by learners and had an effect on the quality of their problem representations. These findings are discussed with respect to the design of additional help systems in problem-oriented learning environments

A methodology for the capture and analysis of hybrid data: a case study of program debugging

No description supplie

Adolescent Literacy and the Achievement Gap: What Do We Know and Where Do We Go From Here?

Reviews research and program initiatives focused on improving adolescent academic achievement by targeting literacy. Provides ideas for collaboration and coordination of funding efforts to improve the literacy achievement of under-performing adolescents

Reify Your Collection Queries for Modularity and Speed!

Modularity and efficiency are often contradicting requirements, such that programers have to trade one for the other. We analyze this dilemma in the context of programs operating on collections. Performance-critical code using collections need often to be hand-optimized, leading to non-modular, brittle, and redundant code. In principle, this dilemma could be avoided by automatic collection-specific optimizations, such as fusion of collection traversals, usage of indexing, or reordering of filters. Unfortunately, it is not obvious how to encode such optimizations in terms of ordinary collection APIs, because the program operating on the collections is not reified and hence cannot be analyzed. We propose SQuOpt, the Scala Query Optimizer--a deep embedding of the Scala collections API that allows such analyses and optimizations to be defined and executed within Scala, without relying on external tools or compiler extensions. SQuOpt provides the same "look and feel" (syntax and static typing guarantees) as the standard collections API. We evaluate SQuOpt by re-implementing several code analyses of the Findbugs tool using SQuOpt, show average speedups of 12x with a maximum of 12800x and hence demonstrate that SQuOpt can reconcile modularity and efficiency in real-world applications.Comment: 20 page