Search

Genetic Improvement (GI) can be used to give better quality software and to create new functionality. We show that GI can evolve the PowerPC open source GNU C runtime library square root function into cube root, binary logarithm log2 and reciprocal square root. The GI cbrt is competitive in run-time performance and our inverted square root x-1/2 is far more accurate than the approximation used in the Quake video game. We use CMA-ES to adapt constants in a Newton-Raphson table, originally from glibc's sqrt, for other double precision mathematics functions. Such automatically customised math libraries might be used for mobile or low resource, IoT, mote, smart dust, bespoke cyber-physical systems. Evolutionary Computing (EC) can be used to not only adapt source code but also data, such as numerical constants, and could enable a new way to conduct software data maintenance. This is an exciting opportunity for the GECCO and optimisation communities.

Test-suite minimization is one key technique for optimizing the software testing process. Due to the need to balance multiple factors, multi-criteria test-suite minimization (MCTSM) becomes a popular research topic in the recent decade. The MCTSM problem is typically modeled as integer linear programming (ILP) problem and solved with weighted-sum single objective approach. However, there is no existing approach that can generate sound (i.e., being Pareto-optimal) and complete (i.e., covering the entire Pareto front) Pareto-optimal solution set, to the knowledge of the authors. In this work, we first prove that the ILP formulation can accurately model the MCTSM problem and then propose the multi-objective integer programming (MOIP) approaches to solve it. We apply our MOIP approaches on three specific MCTSM problems and compare the results with those of the cutting-edge methods, namely, NonlinearFormulation_LinearSolver (NF_LS) and two Multi-Objective Evolutionary Algorithms (MOEAs). The results show that our MOIP approaches can always find sound and complete solutions on five subject programs, using similar or significantly less time than NF_LS and two MOEAs do. The current experimental results are quite promising, and our approaches have the potential to be applied for other similar search-based software engineering problems.

Search-Based Software Engineering (SBSE) researchers who apply multi-objective search algorithms (MOSAs) often assess the quality of solutions produced by MOSAs with one or more quality indicators (QIs). However, SBSE lacks evidence providing insights on commonly used QIs, especially about agreements among them and their relations with SBSE problems and applied MOSAs. Such evidence about QIs agreements is essential to understand relationships among QIs, identify redundant QIs, and consequently devise guidelines for SBSE researchers to select appropriate QIs for their specific contexts. To this end, we conducted an extensive empirical evaluation to provide insights on commonly used QIs in the context of SBSE, by studying agreements among QIs with and without considering differences of SBSE problems and MOSAs. In addition, by defining a systematic process based on three common ways of comparing MOSAs in SBSE, we present additional observations that were automatically produced based on the results of our empirical evaluation. These observations can be used by SBSE researchers to gain a better understanding of the commonly used QIs in SBSE, in particular, regarding their agreements. Finally, based on the results, we also provide a set of guidelines for SBSE researchers to select appropriate QIs for their particular context.

The ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) was held in Tallinn2 -- Estonia, from the 28th to the 30th of August 2019. Additionally, the 11th Symposium on Search-Based Software Engineering (SSBSE) 3was co-located with ESEC/FSE on the 31st of August and 1st of September. Search-based software engineering (SBSE) [1] investigates the usage of search based algorithms to solve hard software engineering problems. Among the applied techniques, evolutionary algorithms are the most commonly used. SBSE has matured along the years, and this can be seen in the visibility it has reached in top-tier software engineering venues such as ESEC/FSE, and of course, in top-tier evolutionary computation venues such as GECCO (which has a special SBSE track!). This year ESEC/FSE held an entire session for SBSE papers, while also being rich in artificial intelligence papers across all other sessions.

Software is vital to modern life, yet much of it is old and suffers from bit-rot. There are not and never will be enough software experts to keep it all up to date by hand. Instead we suggest combining data driven learning with evolutionary search to maintain computer systems. @RE: N. Alshahwan. Industrial experience of genetic improvement in Facebook. In J. Petke, S. H. Tan, W. B. Langdon, and W. Weimer, editors, GI-2019, ICSE workshops proceedings, page 1, Montreal, 28 May 2019. IEEE. Invited Keynote. W. Banzhaf, P. Nordin, R. E. Keller, and F. D. Francone. Genetic Programming - An Introduction; On the Automatic Evolution of Computer Programs and its Applications. Morgan Kaufmann, San Francisco, CA, USA, Jan. 1998. N. Hansen and A. Ostermeier. Completely derandomized self-adaptation in evolution strategies. Evolutionary Computation, 9(2):159--195, Summer 2001. S. Haraldsson, A. Brownlee, and J. R. Woodward. Computers will soon be able to fix themselves - are IT departments for the chop? The Conversation, page 3.29pm BST, Oct. 12 2017. S. O. Haraldsson, J. R. Woodward, A. E. I. Brownlee, and K. Siggeirsdottir. Fixing bugs in your sleep: How genetic improvement became an overnight success. In J. Petke, D. R. White, W. B. Langdon, and W. Weimer, editors, GI-2017, pages 1513--1520, Berlin, 15--19 July 2017. ACM. Best paper. M. Harman and B. F. Jones. Search based software engineering. Information and Software Technology, 43(14):833--839, Dec. 2001. F. Hutter, H. H. Hoos, K. Leyton-Brown, and T. Stuetzle. ParamILS: An automatic algorithm configuration framework. JAIR, 36:267--306, 2009. G. Kendall. Evolutionary computation has been promising self-programming machines for 60 years - so where are they? The Conversation, page 8.54am BST, Mar. 27 2018. J. R. Koza. Genetic Programming: On the Programming of Computers by Natural Selection. MIT press, 1992. W. B. Langdon. Genetic improvement of programs. In R. Matousek, editor, 18th International Con- ference on Soft Computing, MENDEL 2012, Brno, Czech Republic, 27--29 June 2012. Brno University of Technology. Invited keynote. W. B. Langdon and M. Harman. Optimising existing software with genetic programming. IEEE Transactions on Evolutionary Computation, 19(1):118--135, Feb. 2015. W. B. Langdon, B. Y. H. Lam, J. Petke, and M. Harman. Improving CUDA DNA analysis soft- ware with genetic programming. In S. Silva, A. I. Esparcia-Alcazar, M. Lopez-Ibanez, S. Mostaghim, J. Timmis, C. Zarges, L. Correia, T. Soule, M. Giacobini, R. Urbanowicz, Y. Akimoto, T. Glasmach- ers, F. Fernandez de Vega, A. Hoover, P. Larranaga, M. Soto, C. Cotta, F. B. Pereira, J. Handl, J. Koutnik, A. Gaspar-Cunha, H. Trautmann, J.-B. Mouret, S. Risi, E. Costa, O. Schuetze, K. Kraw- iec, A. Moraglio, J. F. Miller, P. Widera, S. Cagnoni, J. Merelo, E. Hart, L. Trujillo, M. Kessentini, G. Ochoa, F. Chicano, and C. Doerr, editors, GECCO '15: Proceedings of the 2015 Annual Conference on Genetic and Evolutionary Computation, pages 1063--1070, Madrid, 11--15 July 2015. ACM. W. B. Langdon and R. Lorenz. Improving SSE parallel code with grow and graft genetic programming. In J. Petke, D. R. White, W. B. Langdon, and W. Weimer, editors, GI-2017, pages 1537--1538, Berlin, 15--19 July 2017. ACM. W. B. Langdon and J. Petke. Evolving better software parameters. In T. E. Colanzi and P. McMinn, editors, SSBSE 2018 Hot off the Press Track, volume 11036 of LNCS, pages 363--369, Montpellier, France, 8--9 Sept. 2018. Springer. W. B. Langdon, J. Petke, and R. Lorenz. Evolving better RNAfold structure prediction. In M. Castelli, L. Sekanina, and M. Zhang, editors, EuroGP 2018: Proceedings of the 21st European Conference on Genetic Programming, volume 10781 of LNCS, pages 220--236, Parma, Italy, 4--6 Apr. 2018. Springer Verlag. C. Le Goues, M. Pradel, and A. Roychoudhury. Automated program repair. Communications of the ACM. To appear. M. Orlov. Evolving software building blocks with FINCH. In J. Petke, D. R. White, W. B. Langdon, and W. Weimer, editors, GI-2017, pages 1539--1540, Berlin, 15--19 July 2017. ACM. L. Perez Caceres, M. Lopez-Ibanez, H. Hoos, and T. Stuetzle. An experimental study of adaptive capping in irace. In R. Battiti, D. E. Kvasov, and Y. D. Sergeyev, editors, Learning and Intelligent Optimization - 11th International Conference, LION 11, Nizhny Novgorod, Russia, June 19--21, 2017, Revised Selected Papers, volume 10556 of Lecture Notes in Computer Science, pages 235--250. Springer, 2017. J. Petke. Constraints: The future of combinatorial interaction testing. In 2015 IEEE/ACM 8th International Workshop on Search-Based Software Testing, pages 17--18, Florence, May 2015. J. Petke, S. O. Haraldsson, M. Harman, W. B. Langdon, D. R. White, and J. R. Woodward. Genetic improvement of software: a comprehensive survey. IEEE Transactions on Evolutionary Computation, 22(3):415--432, June 2018. J. Petke, M. Harman, W. B. Langdon, and W. Weimer. Specialising software for different downstream applications using genetic improvement and code transplantation. IEEE Transactions on Software Engineering, 44(6):574--594, June 2018. R. Poli, W. B. Langdon, and N. F. McPhee. A field guide to genetic programming. Published via http://lulu.com and freely available at http://www.gp-field-guide.org.uk, 2008. (With contri- butions by J. R. Koza). E. Schulte, S. Forrest, and W. Weimer. Automated program repair through the evolution of assembly code. In Proceedings of the IEEE/ACM International Conference on Automated Software Engineering, pages 313--316, Antwerp, 20--24 Sept. 2010. ACM. E. Schulte, W. Weimer, and S. Forrest. Repairing COTS router firmware without access to source code or test suites: A case study in evolutionary software repair. In W. B. Langdon, J. Petke, and D. R. White, editors, Genetic Improvement 2015 Workshop, pages 847--854, Madrid, 11--15 July 2015. ACM. Best Paper. J. R. Woodward, J. Petke, and W. Langdon. How computers are learning to make human software work more efficiently. The Conversation, page 10.08am BST, June 25 2015. K. Yeboah-Antwi and B. Baudry. Online genetic improvement on the java virtual machine with ECSELR. Genetic Programming and Evolvable Machines, 18(1):83--109, Mar. 2017.

A key success of a Web service is to appropriately design its interface to make it easy to consume and understand. In the context of service-oriented computing (SOC), the service’s interface is the main source of interaction with the consumers to reuse the service functionality in real-world applications. The SOC paradigm provides a collection of principles and guidelines to properly design services to provide best practice of third-party reuse. However, recent studies showed that service designers tend to pay little care to the design of their service interfaces, which often lead to several side effects known as antipatterns . One of the most common Web service interface antipatterns is to expose a large number of semantically unrelated operations, implementing different abstractions, in one single interface. Such bad design practices may have a significant impact on the service reusability, understandability, as well as the development and run-time characteristics. To address this problem, in this article, we propose a hybrid approach to improve the design quality of Web service interfaces and fix antipatterns as a combination of both deterministic and heuristic-based approaches. The first step consists of a deterministic approach using a graph partitioning-based technique to split the operations of a large service interface into more cohesive interfaces, each one representing a distinct abstraction. Then, the produced interfaces will be checked using a heuristic-based approach based on the non-dominated sorting genetic algorithm (NSGA-II) to correct potential antipatterns while reducing the interface design deviation to avoid taking the service away from its original design. To evaluate our approach, we conduct an empirical study on a benchmark of 26 real-world Web services provided by Amazon and Yahoo. Our experiments consist of a quantitative evaluation based on design quality metrics, as well as a qualitative evaluation with developers to assess its usefulness in practice. The results show that our approach significantly outperforms existing approaches and provides more meaningful results from a developer’s perspective.

Performance in heterogeneous service-based systems shows non-determistic trends. Even for the same request type, latency may vary from one request to another. These variations can occur due to several reasons on different levels of the software stack: operating system, network, software libraries, application code or others. Furthermore, a request may involve several Remote Procedure Calls (RPC), where each call can be subject to performance variation. Performance analysts inspect distributed traces and seek for recurrent patterns in trace attributes, such as RPCs execution time, in order to cluster traces in which variations may be induced by the same cause. Clustering "similar" traces is a prerequisite for effective performance debugging. Given the scale of the problem, such activity can be tedious and expensive. In this paper, we present an automated approach that detects relevant RPCs execution time patterns associated to request latency degradation, i.e. latency degradation patterns. The presented approach is based on a genetic search algorithm driven by an information retrieval relevance metric and an optimized fitness evaluation. Each latency degradation pattern identifies a cluster of requests subject to latency degradation with similar patterns in RPCs execution time. We show on a microservice-based application case study that the proposed approach can effectively detect clusters identified by artificially injected latency degradation patterns. Experimental results show that our approach outperforms in terms of F-score a state-of-art approach for latency profile analysis and widely popular machine learning clustering algorithms. We also show how our approach can be easily extended to trace attributes other than RPC execution time (e.g. HTTP headers, execution node, etc.).

We report on the application of Genetic Programming to Software Fault Localisation, a problem in the area of Search-Based Software Engineering (SBSE). We give both empirical and theoretical evidence for the human competitiveness of the evolved fault localisation formulæ under the single fault scenario, compared to those generated by human ingenuity and reported in many papers, published over more than a decade. Though there have been previous human competitive results claimed for SBSE problems, this is the first time that evolved solutions have been formally proved to be human competitive. We further prove that no future human investigation could outperform the evolved solutions. We complement these proofs with an empirical analysis of both human and evolved solutions, which indicates that the evolved solutions are not only theoretically human competitive, but also convey similar practical benefits to human-evolved counterparts.

One of the most widely used techniques to improve the quality of existing software systems is refactoring—the process of improving the design of existing code by changing its internal structure without altering its external behavior. While it is important to suggest refactorings that improve the quality and structure of the system, many other criteria are also important to consider, such as reducing the number of code changes, preserving the semantics of the software design and not only its behavior, and maintaining consistency with the previously applied refactorings. In this article, we propose a multi-objective search-based approach for automating the recommendation of refactorings. The process aims at finding the optimal sequence of refactorings that (i) improves the quality by minimizing the number of design defects, (ii) minimizes code changes required to fix those defects, (iii) preserves design semantics, and (iv) maximizes the consistency with the previously code changes. We evaluated the efficiency of our approach using a benchmark of six open-source systems, 11 different types of refactorings (move method, move field, pull up method, pull up field, push down method, push down field, inline class, move class, extract class, extract method, and extract interface) and six commonly occurring design defect types (blob, spaghetti code, functional decomposition, data class, shotgun surgery, and feature envy) through an empirical study conducted with experts. In addition, we performed an industrial validation of our technique, with 10 software engineers, on a large project provided by our industrial partner. We found that the proposed refactorings succeed in preserving the design coherence of the code, with an acceptable level of code change score while reusing knowledge from recorded refactorings applied in the past to similar contexts.

Component Based Software Engineering (CBSE) constructs a quality software system by reusing existing components. For the construction of high-quality software system, reusability plays an important role. Software component should be designed and implemented in such a way that many different programs can reuse them. Reuse of software can increase the productivity and quality of software by reducing effort, time and cost which was elapsed in designing and developing reusable software component. In this paper, a Neuro-fuzzy model has been proposed that uses software component design patterns for analysis and Chidamber and Kemerer (CK) metric for evaluation, optimization and categorization of reusability for component based software. The work is divided into 2 phases. In the first phase, analysis and optimization of reusability are empirically evaluated with high precision value using CK metric and unsupervised Self Organizing Map (SOM) Neural Network. In the second phase, reusability is categorized as very low, low, medium, high and very high using a supervised Back propagation Neural Network (BPNN) and fuzzy inference rules applied on CK metric values. The proposed model may help a software designer to evaluate and optimize the reusability of components while designing software to make quality software system.

Performance bugs are common and can cause a significant deterio ration in the behaviour of a program, leading to costly issues. To detect them and reduce their impact, performance tests are typi cally applied. However, there is a lack of mechanisms to evaluate the quality of performance tests, causing many of these bugs re main unrevealed. Mutation testing, a fault-based technique to assess and improve test suites, has been successfully studied with func tional tests. In this paper, we propose the use of mutation testing together with a search-based strategy (evolutionary algorithm) to find mutants that simulate performance issues. This novel approach contributes to enhance the confidence on performance tests while reducing the cost of mutation testing. Ministerio de Economía y Competitividad BELI (TIN2015-70560-R) Ministerio de Economía y Competitividad TIN2015-65845-C3-3-R

Software clustering is a technique that is used to manage a software system by partitioning it into smaller subsystems containing highly related modules. Search-based software clustering techniques are found to be beneficial in effective partitioning of software systems. In this paper, we propose a search-based technique that is based on a combination of a nature-inspired black-hole algorithm and a genetic algorithm for software clustering. In order to evaluate the success of this approach, it has been applied to some real-world software systems. It is observed that this approach deduces a structure similar to the original architecture of the software system concerned.

Code smells represent design situations that can affect the maintenance and evolution of software. They make the system difficult to evolve. Code smells are detected, in general, using quality metrics that represent some symptoms. However, the selection of suitable quality metrics is challenging due to the absence of consensus in identifying some code smells based on a set of symptoms and also the high calibration effort in determining manually the threshold value for each metric. In this article, we propose treating the generation of code-smell detection rules as a bilevel optimization problem. Bilevel optimization problems represent a class of challenging optimization problems, which contain two levels of optimization tasks. In these problems, only the optimal solutions to the lower-level problem become possible feasible candidates to the upper-level problem. In this sense, the code-smell detection problem can be treated as a bilevel optimization problem, but due to lack of suitable solution techniques, it has been attempted to be solved as a single-level optimization problem in the past. In our adaptation here, the upper-level problem generates a set of detection rules, a combination of quality metrics, which maximizes the coverage of the base of code-smell examples and artificial code smells generated by the lower level. The lower level maximizes the number of generated artificial code smells that cannot be detected by the rules produced by the upper level. The main advantage of our bilevel formulation is that the generation of detection rules is not limited to some code-smell examples identified manually by developers that are difficult to collect, but it allows the prediction of new code-smell behavior that is different from those of the base of examples. The statistical analysis of our experiments over 31 runs on nine open-source systems and one industrial project shows that seven types of code smells were detected with an average of more than 86% in terms of precision and recall. The results confirm the outperformance of our bilevel proposal compared to state-of-art code-smell detection techniques. The evaluation performed by software engineers also confirms the relevance of detected code smells to improve the quality of software systems.

Maintenance is one of the important phases of the software development life cycle which contributes to the effective and long term use of any software system. It can become cumbersome and costly for software maintainers when subsystem boundaries are not clearly defined. Further, the problem gets worse due to the system evolution, lack of current documentation and lack of original design documentation. The application of clustering techniques and tools helps software maintenance programmers to recover high-level views of system designs and hence leads to better understanding and maintenance of software systems. In this paper, we have used a sociopolitical Imperialist Competitive Algorithm for software module clustering and compared it with existing evolutionary approaches. We conclude that the novel socio-political approach produces better quality clusters as compared to the earlier evolutionary genetic approaches.

Software testing is an important and expensive phase of the software development life cycle. Over the past few decades, there has been an ongoing research to automate the process of software testing but the attempts have been constrained by the size and the complexity of software especially due to the use of dynamic memory allocation which makes the software behavior highly unpredictable. The use of metaheuristic global search techniques for software test data generation has been the focus of researchers in recent years. Many new techniques and hybrid methods have been proposed to tackle the problem more effectively. This study provides an overview of the various techniques that have been applied for structural test data generation. It also presents the open areas, challenges and future directions in the field of search based software testing with an emphasis on test data generation for structural testing.

The increase in size and complexity of modern software systems requires scalable, systematic, and automated testing approaches. Model-based testing (MBT), as a systematic and automated test case generation technique, is being successfully applied to verify industrial-scale systems and is supported by commercial tools. However, scalability is still an open issue for large systems, as in practice there are limits to the amount of testing that can be performed in industrial contexts. Even with standard coverage criteria, the resulting test suites generated by MBT techniques can be very large and expensive to execute, especially for system level testing on real deployment platforms and network facilities. Therefore, a scalable MBT technique should be flexible regarding the size of the generated test suites and should be easily accommodated to fit resource and time constraints. Our approach is to select a subset of the generated test suite in such a way that it can be realistically executed and analyzed within the time and resource constraints, while preserving the fault revealing power of the original test suite to a maximum extent. In this article, to address this problem, we introduce a family of similarity-based test case selection techniques for test suites generated from state machines. We evaluate 320 different similarity-based selection techniques and then compare the effectiveness of the best similarity-based selection technique with other common selection techniques in the literature. The results based on two industrial case studies, in the domain of embedded systems, show significant benefits and a large improvement in performance when using a similarity-based approach. We complement these analyses with further studies on the scalability of the technique and the effects of failure rate on its effectiveness. We also propose a method to identify optimal tradeoffs between the number of test cases to run and fault detection.

© ACM, 2012. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version is available from the link below. In the past five years there has been a dramatic increase in work on Search-Based Software Engineering (SBSE), an approach to Software Engineering (SE) in which Search-Based Optimization (SBO) algorithms are used to address problems in SE. SBSE has been applied to problems throughout the SE lifecycle, from requirements and project planning to maintenance and reengineering. The approach is attractive because it offers a suite of adaptive automated and semiautomated solutions in situations typified by large complex problem spaces with multiple competing and conflicting objectives. This article provides a review and classification of literature on SBSE. The work identifies research trends and relationships between the techniques applied and the applications to which they have been applied and highlights gaps in the literature and avenues for further research. EPSRC and EU

Software Design Notation Storage and Inference Mechanism (DNSIM) is capable of storing software designs by using Design Markup Language (DGML) tags and reusing existing design elements to produce new software designs. This mechanism performs search operations on stored designs. The accuracy of the search results depends upon the correctness of the keywords provided to the search process. The challenge is to input the Software Requirement Specification (SRS) document as a search input to DNSIM and to produce the best possible design from existing design elements. This paper proposes a method to produce requirement specification keywords from the formal representation of the SRS. The DNSIM system uses the keywords produced by our method and shows significant improvements and accuracy in the design search results

Mark Harman is widely known in our community for his work on source code analy-sis and testing and was instrumental in the founding of the field of Search Based Software Engineering (SBSE). Since its inception in 2001, SBSE has rapidly grown to include over 800 authors, from 270 institutions spread over 40 countries.

Evolutionary testing is an approach to automating test data generation that uses an evolutionary algorithm to search a test object's input domain for test data. Nested predicates can cause problems for evolutionary testing, because information needed for guiding the search only becomes available as each nested conditional is satisfied. This means that the search process can overfit to early information, making it harder, and sometimes near impossible, to satisfy constraints that only become apparent later in the search. The article presents a testability transformation that allows the evaluation of all nested conditionals at once. Two empirical studies are presented. The first study shows that the form of nesting handled is prevalent in practice. The second study shows how the approach improves evolutionary test data generation.

Software specifications are often lacking, incomplete and outdated in the industry. Lack and incomplete specifications cause various software engineering problems. Studies have shown that program comprehension takes up to 45% of software development costs. One of the root causes of the high cost is the lack-of documented specification. Also, outdated and incomplete specification might potentially cause bugs and compatibility issues. In this paper, we describe novel data mining techniques to mine or reverse engineer these specifications from the pool of software engineering data. A large amount of software data is available for analysis. One form of software data is program execution traces. A program trace can be viewed as a sequence of events collected when a program is run. A set of program traces in turn can be viewed as a sequence database. In this paper, we present some novel work in mining software specifications by employing novel pattern mining and rule mining techniques. Performance studies show the scalability of our technique. Case studies on traces of a real industrial application show the utility of our technique in recovering program specifications from execution traces.

Software Engineering (SE) is a new field compared to other sciences. The term Software Engineering first appeared in late 1950s. SE from its beginning has been continuously in the process of evolution. New approaches, methods, tools and techniques are introduced frequently. The future of Software Engineering is a hot topic and every year many publications discuss the same. The focus of this paper is to explore subareas of SE, predict the possible future of SE and provide a guide to practitioners to choose their careers according to the evolution of SE.

Engineering research differs greatly, both in its aims and in its methods, from traditional "scientific" research. While Sciences deal with the study of existing objects and phenomena, be it physically, metaphysically or conceptually, Engineering is based on how to do things, how to create new objects. For this reason, "scientific" research methods are not always directly applicable to research problems of an engineering nature.In the present article, we concentrate on the problems and research methods of a specific branch of engineering: Software Engineering, discussing, on the one hand, the nature of the method in this field while and, on the other, the similarity of the methods of research in Software Engineering and those of software development.

Software Engineering as a discipline emerged in response to the software crisis perceived by the industry. It is a well known fact that at the beginning of any project, the software industry needs to know how much will it cost to develop and what would be the time required. Resource estimation in software engineering is more challenging than resource estimation in any other industry. A number of resource estimation methods are currently available and the neural network model is one of them. This paper proposes to evaluate various training algorithms in a neural network model and shows which is the best suited for software engineering applications.

End-user programming has become the most common form of programming in use today [2], but there has been little investigation into the dependability of the programs end users create. This is problematic because the dependability of these programs can be very important; in some cases, errors in end-user programs, such as formula errors in spreadsheets, have cost millions of dollars. (For example, see www.theregister.co.uk/content/67/31298.html or panko.cba.hawaii.edu/ssr/Mypapers/whatknow.htm.) We have been investigating ways to address this problem by developing a software engineering paradigm viable for end-user programming, an approach we call end-user software engineering .

The city of Fortaleza, Brazil hosted the sixth edition of the Symposium on Search-Based Software Engineering (SBSE) between the 26th and 29th of August. Brazil was chosen to host the symposium because of its strong and growing SBSE community.

The role of structure in specifying, designing, analysing, constructing and evolving software has been the central theme of our research in Distributed Software Engineering. This structural discipline dictates formalisms and techniques that are compositional, components that are context independent and systems that can be constructed and evolved incrementally. This extended abstract overviews our development of a structural approach to engineering distributed software and gives indications of our future work which moves from explicit to implicit structural specification. With the benefit of hindsight we attempt to give a "rational history" to our research.

Mathematical modelling, especially in software engineering metrics, requires more emphasis to be placed on the validity of the selected mathematical tools and techniques to be used. There are a plethora of occurrences in the recent literature of the misapplication of quantitative techniques together with errors in the underlying mathematics. Software engineering metrics needs to take more care in its use of mathematics if it is to gain credence in the scientific and engineering communities.

The evolution of software engineering to a mature engineering discipline can be accelerated by adopting practices from other mature engineering disciplines. Mature engineering disciplines such as a chemical engineering have extensive systematic design reuse practices. In this paper, design reuse in chemical engineering is compared to current and emerging design reuse in software engineering. This comparison is based on the analogy that a chemical process that is implemented as a chemical plant is comparable to a software architecture that is implemented as a software system. The goal is to gain some insights on how engineering models are used to support systematic design reuse. These insights will help form the basis of model based software engineering.

Since the inception of computers, the software industry has searched for dramatic solutions to its systems development problems. In the latter half of the 1980s and into the 1990s, the search has focused on automated software engineering (computer-assisted software engineering or CASE) tools (see, for example, [17]). Many in the software engineering field claim CASE tools will completely replace the software developer [15]. A more realistic view, however, is that such tools will aid systems developers in the process of specifying, designing, and constructing software systems.

Like many other Software Engineering buzzwords, "Reverse Engineering" emerges as an attempt to formalize some specific tasks, which have long been performed by almost every software development or maintenance team, but which were not judged worth before to be considered an engineering discipline. The emergence of powerful Computer Aided Software Engineering (CASE) tools opens new opportunities for the cost-effective re-use of the investments made in existing software systems, and thus for the development of specific tools and techniques to recover the original design of these systems.While most of the current discussion is centered around the development and utilization of tools to automate the Reverse Engineering Process, our attention focuses on the practical application of these tools and techniques under conditions found in real world entreprises. From this view-point, the scope of the Reverse Engineering Techniques appears to be much broader than implied by the characteristics of individual tools.Our approach is based on experiences gained by CMG in projects, either directly related to Reverse Engineering or dealing with tasks, where specific Reverse Engineering Techniques and Tools were advantageously used (e.g. Software Maintenance, Re-Design, Down-Sizing, Conversion). It also evidentiates some pitfalls, which may lead to the failure of some Reverse Engineering projects.

We discuss two software engineering aspects in the development of complex swarm-based systems.

Software problems originate in real world problems. A software solution must address its real world problem in a satisfactory way. A software engineer must therefore understand the real world problem that their software intends to address. To be able to do this, the software engineer must understand the problem context and how it is to be affected by the proposed software, expressed as the requirements. Without this knowledge the engineer can only hope to chance upon the right solution for the problem. Application of problem-oriented approaches may well be a way of meeting this challenge. This article reports on IWAAPO-2010, an ICSE workshop concerned with recent developments in problem-oriented approaches.

In the beautiful city of Vancouver, ICSE2009 hosted several events devoted to advancing the state-of-the-art in multicore software engineering. Realizing that future performance increases will come form parallelism, the software engineering community is organizing to tackle the problems in this important field. Researchers and practitioners got together to present newest results and discuss future directions.

In order to play a bigger role in software engineering tools, static analysis techniques must take into account the specific needs of this application area, in particular in terms of interaction with the user and scalability. This new perspective requires a reexamination of the field of static program analysis both internally and in connection with related areas like theorem proving and debugging.

Program Design Languages have been used for some time in the informal description of software and as an aid to top-down program construction. In general, such languages have not been amenable to the automatic generation of project management information (such as module interconnection details and complexity measurements) useful in the software engineering process. This paper reviews the characteristics of existing program design languages and suggests a new notation and tool for its manipulation.

Spreadsheet programs are an electronic equivalent of three nearly universal problem solving tools: a pencil, a sheet of paper and a calculator. Decisions, comparing different strategies, optimization and testing "what-if" questions are easy with using spreadsheet programs so they can be successfuly used in software engineering too. In the article we have showed the applications of spreadsheet softwre in estimating project costs and measurement of complexity or difficulty of software systems.

Every science mast have its own method of investigation built on a sound foundation that is empirical, justifiable and verifiable. Software metrics, too, can benefit from this principle. A complex aggregate of tools, ideas, methodologies, programming languages, and varieties of applications go into the development, design, manufacture and maintenance of sofcware. The combinations impose another level of complexity on software.

Software engineering is a discipline in search of objective measures for factors that contribute to software quality. NPATH, which counts the acyclic execution paths through a function, is an objective measure of software complexity related to the ease with which software can be comprehensively tested.