Software engineering for privacy in-the-large

There will be an estimated 35 zettabytes (35$times$10textsuperscript{21}) of digital records worldwide by the year 2020. This effectively amounts to privacy management on an ultra-large-scale. In this briefing, we discuss the privacy challenges posed by such an ultra-large-scale ecosystem - we term this ``Privacy in the Large''. We will contrast existing approaches to privacy management, reflect on their strengths and limitations in this regard and outline key software engineering research and practice challenges to be addressed in the future

Komentar Semi Otomatis Untuk Memudahkan Pemahaman Pada Bahasa Pemrograman Java

Studi memperkirakan bahwa biaya perawatan perangkat lunak meningkat dengan sangat cepat hingga mencapai 90% dari biaya keseluruhan dalam daur hidup pengembangan perangkat lunak. Perawatan perangkat lunak menjadi sangat sulit dikarenakan tidak adanya dokumentasi pada program yang ada. Salah satu bentuk dokumentasi program adalah pemberian komentar program. Komentar sangat berguna dalam pemahaman program dan pemeliharaan program. Komentar memungkinkan pengembang dalam memahami kode lebih cepat dalam pembacaan kode program. Pemberian komentar program biasanya dilakukan manual oleh programmer. Pada tesis ini, dilakukan dua kegiatan pemberian komentar pada bahasa pemrograman java, yaitu pemberian komentar secara otomatis dan pemberian komentar secara semi otomatis. Komentar semi otomatis yang diberikan pada program secara langsung dapat mempermudah proses pemahaman pada program khususnya bahasa pemrograman java. Penggunaan ekspresi regular sangat membantu dalam mempolakan baris kode sumber. Aplikasi yang dibangun oleh peneliti telah mampu memberikan kontribusi pemahaman terhadap program sebesar 14.29% sampai dengan 42.86% ==================================================================================================================The study estimates that the cost of software maintenance is increasing very rapidly until it reaches 90% of the overall cost of the software development life cycle. Software maintenance becomes very difficult due to the lack of documentation on the existing program. One form of program documentation was commenting program. Comments are very useful in understanding the program and maintenance program. The comment allows developers to understand the code faster in reading the program code. Commenting program is usually done manually by the programmer. In this thesis, carried out two activities commenting on the Java programming language, the automatic comment and semi-automatic comment. Semi-automatic comments given on direct program is expected to simplify the process of understanding the particular program java programming language. The use of regular expressions is helpful in patterns of lines of source code. Applications built by the researchers have been able to contribute to the understanding of the program at 14.29% to 42.86%

Pembangunan Link Penelusuran Kebutuhan Fungsional Dan Kode Sumber Berdasarkan Kedekatan Semantik Dan Struktur Kode Sumber Berorientasi Objek

Link penelusuran antara dokumen kebutuhan dan kode sumber sangat membantu dalam proses pengembangan dan pemeliharaan perangkat lunak. Dalam proses pengembangan dan pemeliharaan perangkat lunak, pengembang melakukan perubahan pada kode sumber tetapi sering tidak memperbarui dokumen-dokumen yang menyertai kode sumber. Adanya link penelusuran antara dokumen kebutuhan dengan kode sumber akan meningkatkan kecepatan menemukan bagian mana dari kode sumber yang perlu diubah ketika ada perubahan kebutuhan. Link penelusuran membantu pengembang dalam memahami perangkat lunak yang tidak memiliki dokumen perancangan yang lengkap seperti pada kode sumber terbuka. Dalam kode sumber, suatu method mewakili suatu aksi yang dilakukan untuk menyelesaikan suatu kebutuhan pengguna. Beberapa method dan class bekerja sama, satu method memanggil method lain dengan megirimkan parameter dalam method invocation(pemanggilan method). Pada penelitian ini diusulkan suatu metode untuk membangun link penelusuran antara kebutuhan dan kode sumber menggunakan pemrosesan bahasa alami pada kode sumber dan kedekatan semantik. Kedekatan semantik dihitung antara dokumen kebutuhan dengan method signature dan method invocation. Pemrosesan bahasa alami dilakukan pada semua deklarasi method dalam kode sumber. Selanjutnya dihitung kedekatan semantik antara dokumen kebutuhan dengan phrase hasil pemrosesan bahasa alami untuk menentukan method-method kandidat link penelusuran. Selanjutnya dilakukan penelusuran pada kode sumber untuk menemukan method-method yang dieksekusi secara langsung maupun tidak langsung oleh method kandidat. Nilai akhir kedekatan semantik dihitung dari kedekatan semantik antara kebutuhan dengan method kandidat dan method-method yang dieksekusi. Dengan metode ini diharapkan bisa menemukan bagaimana dan bagian mana dari kode sumber yang menjalankan suatu kebutuhan. Penggunaan metode ini diharapkan bisa meningkatkan keakuratan dalam membangun link penelusuran antara kebutuhan dan kode sumber. ============================================================ Traceability link between requirement document and source code is very helpful in software development and maintenance process. In the process, developer make changes to the source code but often forget to update documents that accompanies the source code. The existence of links between requirement document and source code will increase the speed of finding which parts of the source code that need to be changed when changes are made to requirement. Traceability link helps developers to understand the software that does not have a complete design document as in open source software. In the source code, a method represents an action performed to complete a requirement. Some method and class work together, one method calls another method with the parameter in the method invocation. This research proposed a method to build links between requirement and source code using natural language processing on the source code and semantic similarity. Semantic similarity is calculated between requirement document with method signature and method invocation. Natural language processing is done on all method declarations in the source code. Further semantic similarity computed between requirement document and natural language phrase to determine the methodmethod of candidate link. Next do a search in the source code to find the methodmethod to be executed directly or indirectly by the method candidates. The final value is calculated from the semantic similarity between requirement and method of candidates link and invoked method. This method is expected to be able to find how and which parts of the source code that runs a requirement. The use of this method is expected to be able to increase accuracy in building links between requirement and source code

Information Retrieval-Based Optimization Approaches for Requirement Traceability Recovery

Requirements traceability provides support for important software engineering activities. Requirements traceability recovery (RTR) is becoming increasingly important due to the numerous benefits to the overall quality of software. Improving the RTR problem has become an active topic of research for software engineers; researchers have proposed a number of approaches for improving and automating RTR across the requirements and the source code of the system. Textual analysis and Information Retrieval (IR) techniques have been applied to the RTR problem for many years; however, most of the existing IR-based methodologies applied to the RTR problem are semiautomatic or time-consuming, even though many links are correctly recovered using IR. Thus, there is a need for effective and innovative approaches for automatization in the RTR problem. In this research, we study IR techniques applied to the RTR problem to determine the optimal alternative to RTR across the textual content of requirements and system source code, and propose innovative methodologies based on computational intelligence combine with IR to achieve automatization. We approach the study of the RTR problem as an optimization problem; the problem is formulated as a multi or mono objective search in which we assign one-to-many relationships between each requirement and source code classes by considering similarity in their textual content. The Non-dominated Sorting Genetic Algorithm (NSGA-II) and Artificial Bee Colony (ABC), when combined with IR techniques, appear to provide promising alternatives for finding a complete and accurate list of traceability links. We adapt the NGSA-II and ABC algorithms to solve the RTR problem, generate programing tools for experimentation, and report the results on three open source projects. Results show values of precision and recall above 70%. NSGA-II and ABC are also analyzed based on time complexity using the big-O notation; results indicate NSGA-II is more time efficient and less precise than ABC

Traceability improvement for software miniaturization

On the one hand, software companies try to reach the maximum number of customers, which often translate into integrating more features into their programs, leading to an increase in size, memory footprint, screen complexity, and so on. On the other hand, hand-held devices are now pervasive and their customers ask for programs similar to those they use everyday on their desktop computers. Companies are left with two options, either to develop new software for hand-held devices or perform manual refactoring to port it on hand-held devices, but both options are expensive and laborious. Software miniaturization can aid companies to port their software to hand-held devices. However, traceability is backbone of software miniaturization, without up-to-date traceability links it becomes diffi cult to recover desired artefacts for miniaturized software. Unfortunately, due to continuous changes, it is a tedious and time-consuming task to keep traceability links up-to-date. Often traceability links become outdated or completely vanish. Several traceability recovery approaches have been developed in the past. Each approach has some benefits and limitations. However, these approaches do not tell which factors can affect traceability recovery process. Our current research proposal is based on the premise that controlling potential quality factors and combining different traceability approaches can improve traceability quality for software miniaturization. In this research proposal, we introduce traceability improvement for software miniaturization (TISM) process. TISM has three sub processes, namely, traceability factor controller (TFC), hybrid traceability (HT), and software miniaturization optimization (SMO). TFC is a semi automatic process, it provides solution for factors, that can affect traceability process. TFC uses a generic format to document trace quality affecting factors. TFC results will help practitioners and researcher to improve their tool, techniques, and approaches. In the HT different traceability, recovery approaches are combined to trace functional and non-functional requirements. HT also works on improving precision and recall with the help of TFC. Finally these links have been used by SMO to identify required artefacts and optimize using scalability, performance, and portability parameters. We will conduct two case studies to aid TISM. The contributions of this research proposal can be summarised as follow: (i) traceability support for software miniaturization and optimization, (ii) a hybrid approach that combines the best of available traceability approaches to trace functional, non-functional requirements, and provides return-on-investment analysis, (iii) traceability quality factor controller that records the quality factors and provide support for avoiding or controlling them

Improving Information Retrieval Bug Localisation Using Contextual Heuristics

Software developers working on unfamiliar systems are challenged to identify where and how high-level concepts are implemented in the source code prior to performing maintenance tasks. Bug localisation is a core program comprehension activity in software maintenance: given the observation of a bug, e.g. via a bug report, where is it located in the source code? Information retrieval (IR) approaches see the bug report as the query, and the source files as the documents to be retrieved, ranked by relevance. Current approaches rely on project history, in particular previously fixed bugs and versions of the source code. Existing IR techniques fall short of providing adequate solutions in finding all the source code files relevant for a bug. Without additional help, bug localisation can become a tedious, time- consuming and error-prone task. My research contributes a novel algorithm that, given a bug report and the application’s source files, uses a combination of lexical and structural information to suggest, in a ranked order, files that may have to be changed to resolve the reported bug without requiring past code and similar reports. I study eight applications for which I had access to the user guide, the source code, and some bug reports. I compare the relative importance and the occurrence of the domain concepts in the project artefacts and measure the effectiveness of using only concept key words to locate files relevant for a bug compared to using all the words of a bug report. Measuring my approach against six others, using their five metrics and eight projects, I position an effected file in the top-1, top-5 and top-10 ranks on average for 44%, 69% and 76% of the bug reports respectively. This is an improvement of 23%, 16% and 11% respectively over the best performing current state-of-the-art tool. Finally, I evaluate my algorithm with a range of industrial applications in user studies, and found that it is superior to simple string search, as often performed by developers. These results show the applicability of my approach to software projects without history and offers a simpler light-weight solution

Tracing object-oriented code into functional requirements

Software system documentation is almost always expressed informally, in natural language and free text. Examples include requirement specifications, design documents, manual pages, system development journals, error logs and related maintenance reports. We propose an approach to establish and maintain traceability links between source code and free text documents. A premise of our work is that programmers use meaningful names for program items, such as functions, variables, types, classes, and methods. We believe that the application-domain knowledge that programmers process when writing the code is often captured by the mnemonics for identifiers; therefore, the analysis of these mnemonics can help to associate high level concepts with program concepts, and vice-versa. In this paper, the approach is applied to software written in an object-oriented language, namely Java, to trace classes to functional requirements

Search-Based Software Maintenance and Testing

2012 - 2013In software engineering there are many expensive tasks that are performed during development and maintenance activities. Therefore, there has been a lot of e ort to try to automate these tasks in order to signi cantly reduce the development and maintenance cost of software, since the automation would require less human resources. One of the most used way to make such an automation is the Search-Based Software Engineering (SBSE), which reformulates traditional software engineering tasks as search problems. In SBSE the set of all candidate solutions to the problem de nes the search space while a tness function di erentiates between candidate solutions providing a guidance to the optimization process. After the reformulation of software engineering tasks as optimization problems, search algorithms are used to solve them. Several search algorithms have been used in literature, such as genetic algorithms, genetic programming, simulated annealing, hill climbing (gradient descent), greedy algorithms, particle swarm and ant colony. This thesis investigates and proposes the usage of search based approaches to reduce the e ort of software maintenance and software testing with particular attention to four main activities: (i) program comprehension; (ii) defect prediction; (iii) test data generation and (iv) test suite optimiza- tion for regression testing. For program comprehension and defect prediction, this thesis provided their rst formulations as optimization problems and then proposed the usage of genetic algorithms to solve them. More precisely, this thesis investigates the peculiarity of source code against textual documents written in natural language and proposes the usage of Genetic Algorithms (GAs) in order to calibrate and assemble IR-techniques for di erent software engineering tasks. This thesis also investigates and proposes the usage of Multi-Objective Genetic Algorithms (MOGAs) in or- der to build multi-objective defect prediction models that allows to identify defect-prone software components by taking into account multiple and practical software engineering criteria. Test data generation and test suite optimization have been extensively investigated as search- based problems in literature . However, despite the huge body of works on search algorithms applied to software testing, both (i) automatic test data generation and (ii) test suite optimization present several limitations and not always produce satisfying results. The success of evolutionary software testing techniques in general, and GAs in particular, depends on several factors. One of these factors is the level of diversity among the individuals in the population, which directly a ects the exploration ability of the search. For example, evolutionary test case generation techniques that employ GAs could be severely a ected by genetic drift, i.e., a loss of diversity between solutions, which lead to a premature convergence of GAs towards some local optima. For these reasons, this thesis investigate the role played by diversity preserving mechanisms on the performance of GAs and proposed a novel diversity mechanism based on Singular Value Decomposition and linear algebra. Then, this mechanism has been integrated within the standard GAs and evaluated for evolutionary test data generation. It has been also integrated within MOGAs and empirically evaluated for regression testing. [edited by author]XII n.s