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%

On the Use of Fault Injection to Discover Security Vulnerabilities in Applications

The advent of the Internet has enabled developers to write and share software components with each other more easily. Developers have become increasingly reliant on code other than their own for application development; code that is often not well tested, and lacking any kind of security review, thus exposing its consumers to security vulnerabilities. The goal of this thesis is to adapt existing techniques, and discover new approaches that can be used to discover security vulnerabilities in applications. We use fault injection in each of our techniques and define a set of criteria to evaluate these approaches. The hierarchy of approaches, starting from a black box and ending in a full white box approach, allows a security reviewer to choose a technique depending on the amount of information available about the application under review, time constraints, and extent of security analysis and confidence desired in the program

Dependence Communities in Source Code

Dependence between components in natural systems is a well studied phenomenon in the form of biological and social networks. The concept of community structure arises from the analysis of social networks and has successfully been applied to complex networks in other fields such as biology, physics and computing. We provide empirical evidence that dependence between statements in source code gives rise to community structure. This leads to the introduction of the concept of dependence communities in software and we provide evidence that they reflect the semantic concerns of a program. Current definitions of sliced-based cohesion and coupling metrics are not defined for procedures which do not have clearly defined output variables and definitions of output variable vary from study-to-study. We solve these problems by introducing corresponding new, more efficient forms of slice-based metrics in terms of maximal slices. We show that there is a strong correlation between these new metrics and the old metrics computed using output variables. We conduct an investigation into dependence clusters which are closely related to dependence communities. We undertake an empirical study using definitions of dependence clusters from previous studies and show that, while programs do contain large dependence clusters, over 75% of these are not ‘true’ dependence clusters. We bring together the main elements of the thesis in a study of software quality, investigating their interrelated nature. We show that procedures that are members of multiple communities have a low cohesion, programs with higher coupling have larger dependence communities, programs with large dependence clusters also have large dependence communities and programs with high modularity have low coupling. Dependence communities and maximal-slice-based metrics have a huge number of potential applications including program comprehension, maintenance, debugging, refactoring, testing and software protection