Why Philosophers Should Care About Computational Complexity

One might think that, once we know something is computable, how efficiently it can be computed is a practical question with little further philosophical importance. In this essay, I offer a detailed case that one would be wrong. In particular, I argue that computational complexity theory---the field that studies the resources (such as time, space, and randomness) needed to solve computational problems---leads to new perspectives on the nature of mathematical knowledge, the strong AI debate, computationalism, the problem of logical omniscience, Hume's problem of induction, Goodman's grue riddle, the foundations of quantum mechanics, economic rationality, closed timelike curves, and several other topics of philosophical interest. I end by discussing aspects of complexity theory itself that could benefit from philosophical analysis.Comment: 58 pages, to appear in "Computability: G\"odel, Turing, Church, and beyond," MIT Press, 2012. Some minor clarifications and corrections; new references adde

Quantum Limits, Computational Complexity and Philosophy – A Review: Shamaila Shafiq

Quantum computing physics uses quantum qubits (or bits), for computer’s memory or processor. They can perform certain calculations much faster than a normal computer. The quantum computers have some limitations due to which the problems belonging to NP- Complete are not solved efficiently. This paper covers effective quantum algorithm for solving NP-Complete problems through some features of complexity theory, that we can simplify some of the philosophical interest problems

Refactorings of Design Defects using Relational Concept Analysis

Software engineers often need to identify and correct design defects, ıe} recurring design problems that hinder development and maintenance\ud by making programs harder to comprehend and--or evolve. While detection\ud of design defects is an actively researched area, their correction---mainly\ud a manual and time-consuming activity --- is yet to be extensively\ud investigated for automation. In this paper, we propose an automated\ud approach for suggesting defect-correcting refactorings using relational\ud concept analysis (RCA). The added value of RCA consists in exploiting\ud the links between formal objects which abound in a software re-engineering\ud context. We validated our approach on instances of the <span class='textit'></span>Blob\ud design defect taken from four different open-source programs

Toward the Automatic Classification of Self-Affirmed Refactoring

The concept of Self-Affirmed Refactoring (SAR) was introduced to explore how developers document their refactoring activities in commit messages, i.e., developers explicit documentation of refactoring operations intentionally introduced during a code change. In our previous study, we have manually identified refactoring patterns and defined three main common quality improvement categories including internal quality attributes, external quality attributes, and code smells, by only considering refactoring-related commits. However, this approach heavily depends on the manual inspection of commit messages. In this paper, we propose a two-step approach to first identify whether a commit describes developer-related refactoring events, then to classify it according to the refactoring common quality improvement categories. Specifically, we combine the N-Gram TF-IDF feature selection with binary and multiclass classifiers to build a new model to automate the classification of refactorings based on their quality improvement categories. We challenge our model using a total of 2,867 commit messages extracted from well engineered open-source Java projects. Our findings show that (1) our model is able to accurately classify SAR commits, outperforming the pattern-based and random classifier approaches, and allowing the discovery of 40 more relevent SAR patterns, and (2) our model reaches an F-measure of up to 90% even with a relatively small training datase

Patterns of Change: Can modifiable software have high coupling?

There are few aspects of modern life that remain unaffected by software, and as our day-to-day challenges change, so too must our software. Software systems are complex, and as they grow larger and more interconnected, they become more difficult to modify due to excessive change propagation. This is known as the ripple effect. The primary strategies to mitigate it are modular design, and minimization of coupling, or between-module interaction. However, analysis of complex networks has shown that many are scale-free, which means that they contain some components that are highly connected. The presence of scale-free structure implies high coupling, which suggests that software systems may be hard to modify because they suffer from the ripple effect. In this thesis, a large corpus of open-source software systems is analysed to determine whether software systems are scale-free, whether scale-free structure results in high coupling, and whether high coupling results in ripple effects that propagate change to a large proportion of classes. The results show that all systems in the corpus are scale-free and that that property results in high coupling. However, analysis of system evolution reveals that existing code is modified infrequently and that there is rarely sufficient evidence to be confident that ripple effects involving a high proportion of classes have actually occurred. This thesis concludes first that while it is desirable to avoid excessive interconnectivity, it is difficult to completely eliminate high coupling; and second, that the presence of high coupling does not necessarily imply poor system design