The document discusses various tools for detecting code smells and refactoring opportunities in Java codebases:
1. JDeodorant detects code smells like God Classes and Feature Envy and suggests refactorings. It analyzed a 120k LOC codebase in 11 minutes.
2. JMove identifies Feature Envy smells and proposes moving methods to better classes. It provided 13 suggestions for a codebase in 45 minutes.
3. JSpIRIT identifies 10 code smells and found 1349 in a codebase in 1 minute. Clicking a smell brings you to the problematic code.
4. Stench Blossom identifies smells as you code to avoid stopping work. It indicates smells without suggestions
The document discusses various tools for detecting code smells and refactoring opportunities in Java code:
- JDeodorant detects code smells like God Classes and suggests refactorings. It analyzed a 120K LOC codebase in 11 minutes, finding 115 refactoring opportunities.
- JMove identifies Feature Envy smells and proposes moving methods. It analyzed the same codebase in 45 minutes, providing 13 suggestions.
- JSpIRIT identifies 11 code "disharmonies" and found over 1300 in the codebase within a minute. It ranks issues but does not propose fixes.
- Stench Blossom identifies smells as code is written without slowing development. It indicates severity and provides
This document discusses uncommon Java bugs and how free open source static analysis tools can help detect them. It provides examples of bugs like using the letter "l" instead of the number 1 in a long constant, checking for NaN equality, and null pointer exceptions. The document introduces tools like Jlint, FindBugs, PMD, and QJ-Pro that can find these kinds of bugs and describes how each tool detects bugs in code examples. It concludes that using static analysis tools can improve code quality by finding defects early.
David Parnas - Documentation Based Software Testing - SoftTest IrelandDavid O'Dowd
This document discusses documentation-based software testing and testing approaches. It advocates planning testing early and basing tests on documentation prepared throughout the design process. This allows test plans and evaluation to be determined in advance so high quality standards can be enforced on a project. The document also discusses different types of testing like black box, clear box, and grey box testing and notes that while black box testing tests against specifications, knowledge of internal structure can provide better test coverage.
If you create software that is planned for continuous enhancements over several years then you’ll need a sustainable strategy for code quality.
Code coverage by automated tests is one important metric, and its value should equal 100 per cent at all times.
This talk will show why this is so and how it can be achieved in real world software (with examples in Java)
By Andreas Czakaj, mensemedia Gesellschaft für Neue Medien mbH
This presentation was held at the W-JAX 2017 conference (https://jax.de/core-java-jvm-languages/100-code-coverage-in-real-world-software/)
The document discusses various techniques used to optimize the runtime of a Java application called TopicViewer from over 2 minutes to 18 seconds. Some of the key optimizations included replacing the Colt library with the faster ParallelColt library, avoiding unnecessary object creation, using object arrays instead of maps for better performance, parallelizing loops, using non-blocking data structures for heavy I/O, and profiling the application to identify additional opportunities for improvement. The optimizations reduced the runtime by over 8 times from the original 2 minutes 10 seconds.
This document provides an overview of Java 8 lambda features such as lambda syntax, interface enhancements like default methods, converting anonymous classes to lambdas, forEach and streams, method and constructor references, and functional interfaces. It also lists several sessions at a conference that will provide more in-depth coverage of these Java 8 lambda topics and includes links to documentation and additional resources.
ActiveModel is a gem that provides common interfaces and functionality for model classes, including validation, dirty tracking, callbacks, and serialization. It includes modules like ActiveModel::Validations, ActiveModel::Dirty, and ActiveModel::Callbacks that define APIs for validations, detecting changes, and hooks. While part of Rails, ActiveModel can also be used independently with the 'activemodel' gem. It provides fundamental modeling frameworks that both ActiveRecord and other ORM/ODM gems are built upon.
The document discusses various tools for detecting code smells and refactoring opportunities in Java code:
- JDeodorant detects code smells like God Classes and suggests refactorings. It analyzed a 120K LOC codebase in 11 minutes, finding 115 refactoring opportunities.
- JMove identifies Feature Envy smells and proposes moving methods. It analyzed the same codebase in 45 minutes, providing 13 suggestions.
- JSpIRIT identifies 11 code "disharmonies" and found over 1300 in the codebase within a minute. It ranks issues but does not propose fixes.
- Stench Blossom identifies smells as code is written without slowing development. It indicates severity and provides
This document discusses uncommon Java bugs and how free open source static analysis tools can help detect them. It provides examples of bugs like using the letter "l" instead of the number 1 in a long constant, checking for NaN equality, and null pointer exceptions. The document introduces tools like Jlint, FindBugs, PMD, and QJ-Pro that can find these kinds of bugs and describes how each tool detects bugs in code examples. It concludes that using static analysis tools can improve code quality by finding defects early.
David Parnas - Documentation Based Software Testing - SoftTest IrelandDavid O'Dowd
This document discusses documentation-based software testing and testing approaches. It advocates planning testing early and basing tests on documentation prepared throughout the design process. This allows test plans and evaluation to be determined in advance so high quality standards can be enforced on a project. The document also discusses different types of testing like black box, clear box, and grey box testing and notes that while black box testing tests against specifications, knowledge of internal structure can provide better test coverage.
If you create software that is planned for continuous enhancements over several years then you’ll need a sustainable strategy for code quality.
Code coverage by automated tests is one important metric, and its value should equal 100 per cent at all times.
This talk will show why this is so and how it can be achieved in real world software (with examples in Java)
By Andreas Czakaj, mensemedia Gesellschaft für Neue Medien mbH
This presentation was held at the W-JAX 2017 conference (https://jax.de/core-java-jvm-languages/100-code-coverage-in-real-world-software/)
The document discusses various techniques used to optimize the runtime of a Java application called TopicViewer from over 2 minutes to 18 seconds. Some of the key optimizations included replacing the Colt library with the faster ParallelColt library, avoiding unnecessary object creation, using object arrays instead of maps for better performance, parallelizing loops, using non-blocking data structures for heavy I/O, and profiling the application to identify additional opportunities for improvement. The optimizations reduced the runtime by over 8 times from the original 2 minutes 10 seconds.
This document provides an overview of Java 8 lambda features such as lambda syntax, interface enhancements like default methods, converting anonymous classes to lambdas, forEach and streams, method and constructor references, and functional interfaces. It also lists several sessions at a conference that will provide more in-depth coverage of these Java 8 lambda topics and includes links to documentation and additional resources.
ActiveModel is a gem that provides common interfaces and functionality for model classes, including validation, dirty tracking, callbacks, and serialization. It includes modules like ActiveModel::Validations, ActiveModel::Dirty, and ActiveModel::Callbacks that define APIs for validations, detecting changes, and hooks. While part of Rails, ActiveModel can also be used independently with the 'activemodel' gem. It provides fundamental modeling frameworks that both ActiveRecord and other ORM/ODM gems are built upon.
Are Automated Debugging Techniques Actually Helping ProgrammersChris Parnin
Automated debugging tools may help expert programmers but not others. A study of 34 programmers debugging two programs found:
1) Programmers did not follow ranked lists linearly but jumped around and zig-zagged.
2) When finding the bug, only 1 in 10 stopped investigating while others spent 10 extra minutes.
3) Overall, automated tools did not speed up debugging except for expert programmers who were 5 minutes faster.
4) Developers wanted explanations, not just recommendations from tools. More studies are needed on how programmers use tools.
A Study on Code Smell Detection with Refactoring Tools in Object Oriented Lan...ijcnes
A code smell is an indication in the source code that hypothetically indicates a design problem in the equivalent software. The Code smells are certain code lines which makes problems in source code. It also means that code lines are bad design shape or any code made by bad coding practices. Code smells are structural characteristics of software that may indicates a code or drawing problem that makes software hard to evolve and maintain, and may trigger refactoring of code. In this paper, we proposed some success issues for smell detection tools which can assistance to develop the user experience and therefore the acceptance of such tools. The process of detecting and removing code smells with refactoring can be overwhelming.
The document provides advice for becoming a better programmer based on experience and theory. It discusses maintaining good code quality through principles like DRY (Don't Repeat Yourself), orthogonality, reversibility, prototyping, and domain-specific languages. Specific techniques mentioned include refactoring, testing, modularity, learning new skills regularly, and critically analyzing information to avoid hype. The goal is to produce good-enough software through an iterative process while fighting software entropy.
Chaos Engineering Without Observability ... Is Just ChaosCharity Majors
The document discusses the importance of observability over traditional monitoring for complex distributed systems. It argues that observability allows engineers to understand what is happening inside their systems by asking questions from outside using instrumentation and structured data from the system. True observability requires events with high cardinality and dimensionality to account for unknown problems. It emphasizes testing systems in production and gaining an operational literacy to debug issues without prior knowledge.
This document discusses testing and test-driven development (TDD). It defines testing as validating and verifying the current implementation and design by emulating application states. TDD is presented as an iterative development process that emphasizes design over implementation through continuously writing tests before code (test-first design) and refactoring. Benefits of TDD include cleaner code, early feedback on design/architecture, and more reliable development progress. Drawbacks include requiring a different development approach and tests adding maintenance overhead. Key factors in testing success are the developers and complexity of the problem being solved.
The document discusses refactoring code to improve its design. It defines refactoring as improving code design without changing its external behavior. Refactoring involves identifying "design smells" - symptoms of poor design quality like rigidity, fragility, and opacity. Common smells include long methods, large classes, primitive obsessions, and duplicate code. The document outlines different categories of smells like "bloaters", "object-orientation abusers", and "couplers" that increase coupling between classes. It advises using refactoring tools and techniques to address smells one by one in a refactoring cycle to continuously improve code quality.
This document discusses 10 ways to improve programming code through practices like composing methods, test-driven development, static analysis, and questioning assumptions. It encourages techniques like short single-purpose methods, writing tests before code, using tools like FindBugs, avoiding unnecessary complexity, and continually learning language nuances. Examples show refactoring code to follow these practices. Resources are provided on related topics like pair programming and anti-object-oriented design.
This document provides an overview of debugging techniques and best practices. It discusses what debugging is, common debugging rules and methods, as well as tools and techniques for preventing bugs. Key points covered include understanding the system, making failures reproducible, dividing problems, changing one thing at a time, and keeping an audit trail. The document also mentions code reviews, assertions, and defensive programming as ways to prevent bugs.
This document discusses implementing AppLocker whitelisting to prevent malware execution. It begins by explaining the limitations of traditional antivirus and introduces AppLocker as a "whitelisting" approach that allows only approved applications to run. It then provides guidance on planning and deploying AppLocker, including determining scope, generating application rules, selecting rule types, and configuring Group Policy for enforcement. The presentation aims to demonstrate how AppLocker can eliminate many IT problems by preventing the execution of unauthorized or unknown software.
Refactoring for Software Design Smells - 1 day Workshop Ganesh Samarthyam
The document discusses various design smells that negatively impact software quality attributes like reusability, changeability, understandability and extensibility. It covers different categories of design smells including abstraction smells, encapsulation smells and modularization smells. Some examples of specific smells discussed are missing abstraction, leaky encapsulation, broken modularization etc. The document emphasizes the importance of addressing design smells through refactoring to improve design quality and reduce technical debt.
The document discusses anti-patterns and worst practices in software development. Some examples covered include static cling pattern, flags over objects, premature optimization, copy-paste-compile, and reinventing the wheel. It also shares lessons learned from experiences, such as being mindful of date times across time zones, avoiding building SQL from untrusted inputs, and not being too cute with test data. Overall, the document aims to help developers learn from the mistakes of others and adopt better practices.
The document provides an overview of technologies that are useful for startups. It discusses what a startup is, stages of startup development, product evolution and life cycles, tech stacks, databases, programming languages, and server-side frameworks. The key considerations when choosing technologies include problem fit, performance, productivity, scalability, and maturity of the software/framework. Relational databases are generally the best default option, and other data stores like NoSQL should only be considered if relational databases cannot meet the needed scale.
Software Carpentry and the Hydrological Sciences @ AGU 2013Aron Ahmadia
This document discusses bringing computational skills training to hydrologists through Software Carpentry workshops. It notes that while many hydrologists are focused on their research, computational methods are now essential. Software Carpentry teaches practical skills like the Unix shell, version control with Git, Python and R programming, and databases. These intensive, short workshops have been effective at training graduate students. The document encourages hydrologists to host their own workshops and support computational literacy by discussing code and practices in their papers.
Fast detection of Android malware: machine learning approachYury Leonychev
This is a my presentation for YaC 2013 about machine learning based system for fast classification of Android applications. Covered themes: how to find malware around thousands of applications in Store.
"Быстрое обнаружение вредоносного ПО для Android с помощью машинного обучения...Yandex
В докладе речь пойдёт о применении алгоритмов машинного обучения для обнаружения вредоносных приложений для Android. Я расскажу, как на базе Матрикснета в Яндексе был спроектирован высокопроизводительный инструмент для решения этой задачи. А также продемонстрирую, в каких случаях аналитические методы выявления вредоносного ПО помогают блокировать множество простых образцов вирусного кода. Затем мы поговорим о том, как можно усовершенствовать такие методы для обнаружения более хитроумных вредных программ.
This document discusses various code smells that can indicate issues with software maintainability and design quality. It describes code smells like long methods and classes, duplicated code, dead code, temporary variables, complex conditionals, uncommunicative names, and many others. For each smell, it provides examples and explanations of how and why they hurt code quality and maintenance. The overall message is that identifying and addressing these smells through refactoring can help improve software design and readability.
This document discusses code refactoring. It begins by defining refactoring as restructuring source code to improve readability, fix bugs easily, enhance design, and introduce flexibility without changing functionality. It then provides examples of when to refactor, such as when duplicating logic exists, or to enable sharing of logic between methods. The document also discusses problems that can occur with refactoring, like interface changes breaking other applications, and signs that refactoring is needed, such as duplicate code, long methods, or large classes. It provides guidance on how to identify code that needs refactoring and techniques for refactoring different structures. In the end, it discusses the potential benefits of refactoring, such as increased
Intro to programing with java-lecture 1Mohamed Essam
The document provides an introduction to Java programming, including definitions of Java, how Java works, and the basic structure of a Java program. It explains that Java code is compiled to bytecode that can run on any device, and discusses the typical components of a Java program, including classes, methods, and the main method where program execution begins. It also provides a simple "Hello World" example Java program to demonstrate how a basic Java file is structured.
1. Giorgio Zoppi discussed principles of structured software design and distributed message queues. He talked about minimizing complexity through problem decomposition, information hiding, and reducing change amplification.
2. Designing a distributed message queue involves key requirements like multiple producers and consumers, no single point of failure, sequential consistency, and data durability. Messages can be sent, received, and deleted from queues while ensuring non-loss of data.
3. The objectives of structured design are to achieve reliability, maintainability, and scalability through principles such as loose coupling, high cohesion, and minimizing unknown unknowns.
Works For Me! Characterizing Non-Reproducible Bug ReportsSALT Lab @ UBC
This document summarizes research into non-reproducible (NR) bug reports. The researchers analyzed over 188,000 bug reports from 6 open source projects. They found that NR bugs made up 17% of reports and were active longer than other bugs. Common causes of NR bugs included environmental differences between developers and users, insufficient information in bug reports, and conflicting expectations about how software should behave. Nearly half of NR bugs were eventually fixed but were initially mislabeled due to inconsistencies in resolution definitions and a lack of appropriate resolution options.
The document summarizes key points from the JavaOne 2011 conference. It discusses new features in Java SE 7 like underscores in numbers, strings in switch statements, and try-with-resources. It also covers upcoming features for Java 8/9 like modularity, closures, and Nashorn JavaScript support. The document notes enhancements to Java EE 7 including elasticity and multi-tenancy. It provides a demo of these features in Glassfish 4.
Java 8 will include many new features including lambdas, default methods on interfaces, and a date/time API. Lambdas allow implementing functional interfaces with expression syntax rather than anonymous classes, and method references allow referring to methods without invoking them. Default methods allow adding new functionality to interfaces without breaking existing implementations. The new date/time API in JSR-310 provides improved date/time handling functionality.
Are Automated Debugging Techniques Actually Helping ProgrammersChris Parnin
Automated debugging tools may help expert programmers but not others. A study of 34 programmers debugging two programs found:
1) Programmers did not follow ranked lists linearly but jumped around and zig-zagged.
2) When finding the bug, only 1 in 10 stopped investigating while others spent 10 extra minutes.
3) Overall, automated tools did not speed up debugging except for expert programmers who were 5 minutes faster.
4) Developers wanted explanations, not just recommendations from tools. More studies are needed on how programmers use tools.
A Study on Code Smell Detection with Refactoring Tools in Object Oriented Lan...ijcnes
A code smell is an indication in the source code that hypothetically indicates a design problem in the equivalent software. The Code smells are certain code lines which makes problems in source code. It also means that code lines are bad design shape or any code made by bad coding practices. Code smells are structural characteristics of software that may indicates a code or drawing problem that makes software hard to evolve and maintain, and may trigger refactoring of code. In this paper, we proposed some success issues for smell detection tools which can assistance to develop the user experience and therefore the acceptance of such tools. The process of detecting and removing code smells with refactoring can be overwhelming.
The document provides advice for becoming a better programmer based on experience and theory. It discusses maintaining good code quality through principles like DRY (Don't Repeat Yourself), orthogonality, reversibility, prototyping, and domain-specific languages. Specific techniques mentioned include refactoring, testing, modularity, learning new skills regularly, and critically analyzing information to avoid hype. The goal is to produce good-enough software through an iterative process while fighting software entropy.
Chaos Engineering Without Observability ... Is Just ChaosCharity Majors
The document discusses the importance of observability over traditional monitoring for complex distributed systems. It argues that observability allows engineers to understand what is happening inside their systems by asking questions from outside using instrumentation and structured data from the system. True observability requires events with high cardinality and dimensionality to account for unknown problems. It emphasizes testing systems in production and gaining an operational literacy to debug issues without prior knowledge.
This document discusses testing and test-driven development (TDD). It defines testing as validating and verifying the current implementation and design by emulating application states. TDD is presented as an iterative development process that emphasizes design over implementation through continuously writing tests before code (test-first design) and refactoring. Benefits of TDD include cleaner code, early feedback on design/architecture, and more reliable development progress. Drawbacks include requiring a different development approach and tests adding maintenance overhead. Key factors in testing success are the developers and complexity of the problem being solved.
The document discusses refactoring code to improve its design. It defines refactoring as improving code design without changing its external behavior. Refactoring involves identifying "design smells" - symptoms of poor design quality like rigidity, fragility, and opacity. Common smells include long methods, large classes, primitive obsessions, and duplicate code. The document outlines different categories of smells like "bloaters", "object-orientation abusers", and "couplers" that increase coupling between classes. It advises using refactoring tools and techniques to address smells one by one in a refactoring cycle to continuously improve code quality.
This document discusses 10 ways to improve programming code through practices like composing methods, test-driven development, static analysis, and questioning assumptions. It encourages techniques like short single-purpose methods, writing tests before code, using tools like FindBugs, avoiding unnecessary complexity, and continually learning language nuances. Examples show refactoring code to follow these practices. Resources are provided on related topics like pair programming and anti-object-oriented design.
This document provides an overview of debugging techniques and best practices. It discusses what debugging is, common debugging rules and methods, as well as tools and techniques for preventing bugs. Key points covered include understanding the system, making failures reproducible, dividing problems, changing one thing at a time, and keeping an audit trail. The document also mentions code reviews, assertions, and defensive programming as ways to prevent bugs.
This document discusses implementing AppLocker whitelisting to prevent malware execution. It begins by explaining the limitations of traditional antivirus and introduces AppLocker as a "whitelisting" approach that allows only approved applications to run. It then provides guidance on planning and deploying AppLocker, including determining scope, generating application rules, selecting rule types, and configuring Group Policy for enforcement. The presentation aims to demonstrate how AppLocker can eliminate many IT problems by preventing the execution of unauthorized or unknown software.
Refactoring for Software Design Smells - 1 day Workshop Ganesh Samarthyam
The document discusses various design smells that negatively impact software quality attributes like reusability, changeability, understandability and extensibility. It covers different categories of design smells including abstraction smells, encapsulation smells and modularization smells. Some examples of specific smells discussed are missing abstraction, leaky encapsulation, broken modularization etc. The document emphasizes the importance of addressing design smells through refactoring to improve design quality and reduce technical debt.
The document discusses anti-patterns and worst practices in software development. Some examples covered include static cling pattern, flags over objects, premature optimization, copy-paste-compile, and reinventing the wheel. It also shares lessons learned from experiences, such as being mindful of date times across time zones, avoiding building SQL from untrusted inputs, and not being too cute with test data. Overall, the document aims to help developers learn from the mistakes of others and adopt better practices.
The document provides an overview of technologies that are useful for startups. It discusses what a startup is, stages of startup development, product evolution and life cycles, tech stacks, databases, programming languages, and server-side frameworks. The key considerations when choosing technologies include problem fit, performance, productivity, scalability, and maturity of the software/framework. Relational databases are generally the best default option, and other data stores like NoSQL should only be considered if relational databases cannot meet the needed scale.
Software Carpentry and the Hydrological Sciences @ AGU 2013Aron Ahmadia
This document discusses bringing computational skills training to hydrologists through Software Carpentry workshops. It notes that while many hydrologists are focused on their research, computational methods are now essential. Software Carpentry teaches practical skills like the Unix shell, version control with Git, Python and R programming, and databases. These intensive, short workshops have been effective at training graduate students. The document encourages hydrologists to host their own workshops and support computational literacy by discussing code and practices in their papers.
Fast detection of Android malware: machine learning approachYury Leonychev
This is a my presentation for YaC 2013 about machine learning based system for fast classification of Android applications. Covered themes: how to find malware around thousands of applications in Store.
"Быстрое обнаружение вредоносного ПО для Android с помощью машинного обучения...Yandex
В докладе речь пойдёт о применении алгоритмов машинного обучения для обнаружения вредоносных приложений для Android. Я расскажу, как на базе Матрикснета в Яндексе был спроектирован высокопроизводительный инструмент для решения этой задачи. А также продемонстрирую, в каких случаях аналитические методы выявления вредоносного ПО помогают блокировать множество простых образцов вирусного кода. Затем мы поговорим о том, как можно усовершенствовать такие методы для обнаружения более хитроумных вредных программ.
This document discusses various code smells that can indicate issues with software maintainability and design quality. It describes code smells like long methods and classes, duplicated code, dead code, temporary variables, complex conditionals, uncommunicative names, and many others. For each smell, it provides examples and explanations of how and why they hurt code quality and maintenance. The overall message is that identifying and addressing these smells through refactoring can help improve software design and readability.
This document discusses code refactoring. It begins by defining refactoring as restructuring source code to improve readability, fix bugs easily, enhance design, and introduce flexibility without changing functionality. It then provides examples of when to refactor, such as when duplicating logic exists, or to enable sharing of logic between methods. The document also discusses problems that can occur with refactoring, like interface changes breaking other applications, and signs that refactoring is needed, such as duplicate code, long methods, or large classes. It provides guidance on how to identify code that needs refactoring and techniques for refactoring different structures. In the end, it discusses the potential benefits of refactoring, such as increased
Intro to programing with java-lecture 1Mohamed Essam
The document provides an introduction to Java programming, including definitions of Java, how Java works, and the basic structure of a Java program. It explains that Java code is compiled to bytecode that can run on any device, and discusses the typical components of a Java program, including classes, methods, and the main method where program execution begins. It also provides a simple "Hello World" example Java program to demonstrate how a basic Java file is structured.
1. Giorgio Zoppi discussed principles of structured software design and distributed message queues. He talked about minimizing complexity through problem decomposition, information hiding, and reducing change amplification.
2. Designing a distributed message queue involves key requirements like multiple producers and consumers, no single point of failure, sequential consistency, and data durability. Messages can be sent, received, and deleted from queues while ensuring non-loss of data.
3. The objectives of structured design are to achieve reliability, maintainability, and scalability through principles such as loose coupling, high cohesion, and minimizing unknown unknowns.
Works For Me! Characterizing Non-Reproducible Bug ReportsSALT Lab @ UBC
This document summarizes research into non-reproducible (NR) bug reports. The researchers analyzed over 188,000 bug reports from 6 open source projects. They found that NR bugs made up 17% of reports and were active longer than other bugs. Common causes of NR bugs included environmental differences between developers and users, insufficient information in bug reports, and conflicting expectations about how software should behave. Nearly half of NR bugs were eventually fixed but were initially mislabeled due to inconsistencies in resolution definitions and a lack of appropriate resolution options.
The document summarizes key points from the JavaOne 2011 conference. It discusses new features in Java SE 7 like underscores in numbers, strings in switch statements, and try-with-resources. It also covers upcoming features for Java 8/9 like modularity, closures, and Nashorn JavaScript support. The document notes enhancements to Java EE 7 including elasticity and multi-tenancy. It provides a demo of these features in Glassfish 4.
Java 8 will include many new features including lambdas, default methods on interfaces, and a date/time API. Lambdas allow implementing functional interfaces with expression syntax rather than anonymous classes, and method references allow referring to methods without invoking them. Default methods allow adding new functionality to interfaces without breaking existing implementations. The new date/time API in JSR-310 provides improved date/time handling functionality.
Explores and discusses benefits of functional programming in Java and how to program in a functional style. Watch Venkat Subramaniam's talk at https://youtu.be/Ee5t_EGjv0A if you would like to learn more.
The document outlines a presentation on migrating to Maven 2. It will provide a brief overview of Maven 2 including the pom.xml file, multi-module builds with parent and child POMs, and the build, site, and clean lifecycles. The presentation will then demonstrate migrating the core Guice module to Maven and converting the build to be multi-module.
Recognize, assess, reduce, and manage technical debtJim Bethancourt
Presents strategies for identifying, assessing, reducing, and managing technical debt at a structural level. Provides both technical and strategic business solutions.
Overview of Bamboo's Continuous Integration and Continuous Delivery features, including branch-per-issue unified development workflow. Also includes supported Operating Systems, Databases, and User Authentication mechanisms.
Flutter is a popular open source, cross-platform framework developed by Google. In this webinar we'll explore Flutter and its architecture, delve into the Flutter Embedder and Flutter’s Dart language, discover how to leverage Flutter for embedded device development, learn about Automotive Grade Linux (AGL) and its consortium and understand the rationale behind AGL's choice of Flutter for next-gen IVI systems. Don’t miss this opportunity to discover whether Flutter is right for your project.
Malibou Pitch Deck For Its €3M Seed Roundsjcobrien
French start-up Malibou raised a €3 million Seed Round to develop its payroll and human resources
management platform for VSEs and SMEs. The financing round was led by investors Breega, Y Combinator, and FCVC.
E-Invoicing Implementation: A Step-by-Step Guide for Saudi Arabian CompaniesQuickdice ERP
Explore the seamless transition to e-invoicing with this comprehensive guide tailored for Saudi Arabian businesses. Navigate the process effortlessly with step-by-step instructions designed to streamline implementation and enhance efficiency.
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdfVALiNTRY360
Salesforce Healthcare CRM, implemented by VALiNTRY360, revolutionizes patient management by enhancing patient engagement, streamlining administrative processes, and improving care coordination. Its advanced analytics, robust security, and seamless integration with telehealth services ensure that healthcare providers can deliver personalized, efficient, and secure patient care. By automating routine tasks and providing actionable insights, Salesforce Healthcare CRM enables healthcare providers to focus on delivering high-quality care, leading to better patient outcomes and higher satisfaction. VALiNTRY360's expertise ensures a tailored solution that meets the unique needs of any healthcare practice, from small clinics to large hospital systems.
For more info visit us https://valintry360.com/solutions/health-life-sciences
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
Liberarsi dai framework con i Web Component.pptxMassimo Artizzu
In Italian
Presentazione sulle feature e l'utilizzo dei Web Component nell sviluppo di pagine e applicazioni web. Racconto delle ragioni storiche dell'avvento dei Web Component. Evidenziazione dei vantaggi e delle sfide poste, indicazione delle best practices, con particolare accento sulla possibilità di usare web component per facilitare la migrazione delle proprie applicazioni verso nuovi stack tecnologici.
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Drona Infotech is a premier mobile app development company in Noida, providing cutting-edge solutions for businesses.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
What to do when you have a perfect model for your software but you are constrained by an imperfect business model?
This talk explores the challenges of bringing modelling rigour to the business and strategy levels, and talking to your non-technical counterparts in the process.
Measures in SQL (SIGMOD 2024, Santiago, Chile)Julian Hyde
SQL has attained widespread adoption, but Business Intelligence tools still use their own higher level languages based upon a multidimensional paradigm. Composable calculations are what is missing from SQL, and we propose a new kind of column, called a measure, that attaches a calculation to a table. Like regular tables, tables with measures are composable and closed when used in queries.
SQL-with-measures has the power, conciseness and reusability of multidimensional languages but retains SQL semantics. Measure invocations can be expanded in place to simple, clear SQL.
To define the evaluation semantics for measures, we introduce context-sensitive expressions (a way to evaluate multidimensional expressions that is consistent with existing SQL semantics), a concept called evaluation context, and several operations for setting and modifying the evaluation context.
A talk at SIGMOD, June 9–15, 2024, Santiago, Chile
Authors: Julian Hyde (Google) and John Fremlin (Google)
https://doi.org/10.1145/3626246.3653374
UI5con 2024 - Bring Your Own Design SystemPeter Muessig
How do you combine the OpenUI5/SAPUI5 programming model with a design system that makes its controls available as Web Components? Since OpenUI5/SAPUI5 1.120, the framework supports the integration of any Web Components. This makes it possible, for example, to natively embed own Web Components of your design system which are created with Stencil. The integration embeds the Web Components in a way that they can be used naturally in XMLViews, like with standard UI5 controls, and can be bound with data binding. Learn how you can also make use of the Web Components base class in OpenUI5/SAPUI5 to also integrate your Web Components and get inspired by the solution to generate a custom UI5 library providing the Web Components control wrappers for the native ones.
2. 1
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
Agenda
3. 2
Your Code Stinks!
The following are from Object Oriented Metrics in Practice, Lanza & Marinescu (2004)
God Class – Performs too much work on its own and centralizes the intelligence of a system. Reduces
reusability, understandability, and maintainability of a class or subsystem.
Feature Envy – Method that is more interested in the data of other classes than its own class. The
method may be misplaced and should be moved to another class.
Data Class – “Dumb” data holders without complex functionality but other classes strongly rely on them.
Brain Method – Centralizes the functionality of a class, and is often hard to maintain and understand.
Is long, has excessive branching, deep nesting, and uses many local and instance variables.
Brain Class – Similar to God Classes in that they are large and complex, but do not abusively access the
data of “satellite” classes or are more cohesive. They have at least one Brain Method.
Intensive Coupling – A single client method is strongly coupled with only a few provider classes.
Dispersed Coupling – A single method is excessively tied to many other operations dispersed among
many classes.
Shotgun Surgery – A single method has many methods in other classes depending on it.
Refused Parent Bequest – Child class does not specialize its parent class
Tradition Breaker – Child class does not enhance / specialize the functionality of the parent class
Disharmonies We’ll be Talking About Today
4. 3
Your Code Stinks!
How the Disharmonies are Related
From Object Oriented Metrics in Practice, Lanza & Marinescu (2004)
5. 4
Your Code Stinks!
God Classes
• 5 – 7 times more change prone
• 4 – 19 times more bug prone
Dispersed Coupling
• Points to defect and maintenance prone classes
From the Technical Debt webinar at
https://fc-d.umd.edu/sites/default/files/Publications/ReportsAndPresentations/TD_webinar_11_11_10.pdf
The Worst Offenders
6. 5
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
7. 6
JDeodorant
Detects several code smells and provides actionable suggestions to remedy them:
• God Class
• Long Method
• Type Checking
• Feature Envy
• Duplicated Code (not discussed here)
Project site: http://users.encs.concordia.ca/~nikolaos/jdeodorant/
Written by a team of professors and PhD students
About JDeodorant
8. 7
JDeodorant
1) Install from the update site http://users.encs.concordia.ca/~nikolaos/update/
2) Open the desired smell detection strategy from the Bad Smells menu
How to Use JDeodorant
9. 8
JDeodorant
3) Select the project you would like scanned from the Package Explorer
4) Click on the i button in the opened smell view to start the scan
How to use JDeodorant
10. 9
JDeodorant
Identifies God classes and proposes class extraction refactorings
Took 11 minutes (w/3GB RAM) to analyze JHotDraw 7.6 (120K LOC) and produced 115 suggestions
God Class
11. 10
JDeodorant
Iidentifies Feature Envy smells and suggests Move Method refactorings
Took about 5 min (w/3GB RAM) to run against JHotDraw 7.6
Feature Envy
12. 11
JDeodorant
A long method may not be entirely cohesive and it may be possible to extract one or more blocks of logic
into a separate method, making the method easier to understand and maintain.
Took 1 hour and 40 minutes to analyze JHotDraw 7.6 (w/3GB RAM) and didn’t find any instances of this
smell. May run faster with more memory.
Long Method
Picture from JDeodorant Site
13. 12
JDeodorant
The Type Checking scan identifies where polymorphism or the strategy pattern should be used
Took less than 10 seconds to analyze JHotDraw 7.6 and did not find any instances of this smell.
Type Checking
Picture from JDeodorant Site
14. 13
JDeodorant
Pros
Open Sourced under the Eclipse Public License at https://github.com/tsantalis/JDeodorant
Works in the most recent release of Eclipse
Provides UML visualizations
At version 5.0 and is mature and full-featured
Successfully works in most recent release of Eclipse (Mars R.2)
Once project is parsed for a smell, incremental scans can quickly be re-run against individual packages or
classes
Cons
Can’t run in the background
Some detections can take a long time for medium and large projects
Pros and Cons
15. 14
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
16. 15
JMove
• JMove identfies Feature Envy smells and suggests Move Method refactorings
• If the method is could be moved to multiple classes, a recommendation is made to move it to the class
where it will be the most similar to the other methods in that class
• Project page: http://aserg.labsoft.dcc.ufmg.br/jmove/ (links to paper and plugin)
• Took 45 minutes against JHotDraw 7.6 w/3GB RAM and provided 13 suggestions
• Checks if a method has more similarities to the methods in another class than its current class. It
takes dependencies of the following types between the current class and possible target classes into
account:
• Method Calls
• Field accesses
• Object Instantiations
• Local Declarations
• Return Types
• Exceptions
• Annotations
About JMove
17. 16
JMove
1) Download from http://aserg.labsoft.dcc.ufmg.br/jmove/ and unzip in your Eclipse installation root
directory.
2) Start Eclipse and select Bad Smells -> JMove or Refactorings -> JMove from the menu.
3) Select the project you’d like scanned from the Package Explorer.
4) Click on the i button in the JMove view to start the scan
How to use JMove
19. 18
JMove
Pros
• Tool authors found that JMove‘s precision and recall were 60% and 81%, compared to 26% and 54%
for JDeodorant. Authors found it produced fewer recommendations, but they were better.
• Open sourced under the MIT license at https://github.com/vitormsales/JMove
• Easy to install and use
Cons
• Required to scan an entire Eclipse project – no incremental re-scans
• Can’t be run in the background
• Has been at Beta 0.1 for 3 years
• Not under active development
• Stops working mid-analysis in the Eclipse Mars.2 (4.5.2) but works in Mars (4.5.0)
Pros and Cons
20. 19
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
21. 20
JSpIRIT
Identifies 10 of the 11 code disharmonies presented in Lanza & Merinescu’s “Object Oriented Metrics in
Practice” The Significant Duplication disharmony was not included
Found 1349 disharmonies in JHotDraw 7.6 in 1 minute (with 2 GB RAM)
Identified disharmonies can be clicked on to show where the disharmony is located in the codebase
About JSpIRIT
22. 21
JSpIRIT
1) Download the non-agglomeration version from the JSpIRIT page at
https://sites.google.com/site/santiagoavidal/projects/jspirit
2) Copy it to the dropins directory of your Eclipse installation and start Eclipse
3) Select the project you’d like to analyze, right click it, and select JSpIRIT -> Find Code Smells
How to use JSpIRIT
23. 22
JSpIRIT
How to use JSpIRIT
The JSpIRIT View will pop up once the analysis is complete
Clicking on the item in the view will bring you to the afflicted class or method
24. 23
JSpIRIT
Pros
Works with most recent release of Eclipse (Mars.2 / 4.5.2)
Ranks which design flaws are the worst
Clicking on the design flaw brings you to the element in the code
Ranking is configurable
Free as in beer
Cons
Must be run on entire project. No incremental analysis is possible
Does not propose fixes or specifics about the problem
Eclipse not responsive during analysis
Agglomeration view produces errors in the Agglomeration version
Not open source
Pros and Cons
25. 24
JSpIRIT
Similar to JSpIRIT in its goal of detecting same disharmonies
Available from
https://sewiki.iai.uni-bonn.de/research/cultivate/tutorial_exploring_smells_and_metrics
Unfortunately it is a bit difficult to set up and use
Similar Tool: Cultivate
26. 25
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
27. 26
Stench Blossom
Identifies code smells as you develop and makes you aware of them without getting in your way.
Detects 10 code smells and indicates their severity:
• Data Clumps
• Feature Envy
• Message Chain
• Switch Statement
• Typecast
• InstanceOf
• Long Method
• Large Class
• Primitive Obsession
• Magic Number
• (Long) Comments
• Duplicated Code
About Stench Blossom
28. 27
Stench Blossom
Install the Stench Blossom Eclipse plugin from
https://github.com/CaptainEmerson/refactoring-
tools/raw/master/installables/update_sites/stench_blossom
Enable the Stench Blossom Smell Indicator in the Eclipse Toolbar
Installing Stench Blossom
29. 28
Stench Blossom
Less obvious smells -> orange and above the horizontal line
Obvious smells -> blue and below the horizontal line
Horizontal (thin) line appears if the cursor is not in the editor
Each smell has a specific wedge
Worse the smell, the larger the radius
Understanding the Ambient View
30. 29
Stench Blossom
Hovering your mouse over a wedge shows which smell it is indicating
Clicking on the tooltip will enable the Exploration View
Using the Active View
31. 30
Stench Blossom
Using the Explanation View
References to methods and variables of external classes are highlighted
Suggestions not provided on purpose to allow developer to come up with the best solution
Explanation views can be pinned / prevented from scrolling by clicking on the staple icon
33. 32
Stench Blossom
Pros
Identifies smells as you work, avoiding the need to stop working and wait for analysis to complete
Does not slow the IDE down
Open Sourced at https://github.com/DeveloperLiberationFront/refactoring-tools
Documented in https://pdfs.semanticscholar.org/5705/85ed977bf37b586d6a01e2845a388afb1a26.pdf
All features work in Eclipse Mars R.2
Cons
Not sure if it works with Java 8 features since it was last updated over 2 years ago
Pros and Cons
34. 33
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
35. 34
TopicViewer
Analyzes words used in source files. Can optionally include Javadoc and comments in vocabulary
extraction.
Produces a colorful map with recommendations of classes that belong together.
Project site at https://code.google.com/archive/p/topic-viewer/
I’ve exported the code from Google Code to https://github.com/jimbethancourt/topic-viewer and recently
improved semantic clustering performance by more than 2X (2:10 mins -> 43sec onJHotDraw) for
version under source control.
Downloadable from https://dl.dropboxusercontent.com/u/67114006/TopicViewer.rar (from Google Code
project site)
Vocabulary Extraction (1st step) took about 30 seconds for JHotDraw 7.6 (using defaults)
Semantic Clustering (2nd step) took less than 1 minute and 30 seconds for downloaded version
About TopicViewer
37. 36
TopicViewer
1) Download Topic Viewer from https://dl.dropboxusercontent.com/u/67114006/TopicViewer.rar
and unzip
2) Double-click the TopicViewer.jar and TopicViewer starts. To use more memory than the default
heap size of your JVM, you will need to launch it from the command line or a batch file.
Installing TopicViewer
39. 38
TopicViewer
Select a workspace directory where the project files for a single codebase analysis will live
Click Open Workspace
You should get the message “Workspace has just been configured” once complete
Step 2: Select a Workspace
41. 40
TopicViewer
Click the Select button (on the top right) and select desired root directory of your codebase. Be
careful you don’t include test directories if you don’t want them included in the analysis.
Set desired analysis options and click the Start button.
Step 4: Run Semantic Analysis of Codebase
42. 41
TopicViewer
Click on Activities -> Semantic Clustering
Specify parameters (I take the defaults)
Click Select on the Top right, select workspace/lsi/src-root-directory-name.matrix, and click Open
Click Start on the bottom left
Step 5: Run Semantic Clustering
43. 42
TopicViewer
Select Activities -> View Results -> Distribution Map
Click Select in the top left and select workspace/correlation/src-root-directory-name.matrix
Classes that may belong together in the same package have the same color / number
Step 6: Open Distribution Map
44. 43
TopicViewer
Pros
Produces insightful and helpful suggestions
Simple
Cons
No guided workflow
App not responsive during analysis
Progress bar doesn’t update until it’s complete
Medium and large codebases require more memory and time.
Attempts implement concurrency and streams have failed miserably.
Notes
Downloaded version run faster for large codebases since it uses Sparse matrices in some spots and
needs less memory.
May be worth backing out the Parallel Colt migration and re-applying code changes made in the
HierarchicalClustering class (mostly fixing equals / not equals checks)
Pros and Cons
45. 44
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
46. 45
iPlasma
Tool for performing quality analysis of object-oriented software systems
Development led by the authors of the book Object Oriented Metrics in Practice
Project page: http://loose.upt.ro/reengineering/research/iplasma
Download from http://loose.upt.ro/iplasma/iplasma.zip
Once unzipped, run unzip_DiriPlasma6toolsiPlasmainsider.bat to launch iPlasma
About iPlasma
48. 47
iPlasma
Enter the path of the root directory of the codebase you want to analyze in the Source path textbox.
You can also navigate to it and select it by clicking on the “…” button
The Cache file name textbox can be left blank
Click OK and the model will load. JHotDraw 7.6 loaded in just over a minute (1:04)
Using iPlasma
49. 48
iPlasma
Once codebase is loaded, you’re presented with an Overview Pyramid.
Quick explanation available at https://sewiki.iai.uni-
bonn.de/research/cultivate/tutorial_exploring_smells_and_metrics#overview_pyramid
Using iPlasma
50. 49
iPlasma
Click on the directory you’re interested in learning more about and the Group menu option will
activate:
Using iPlasma
51. 50
iPlasma
The Group menu allows you to select a group of metrics (most but not all work).
iPlasma’s Group Menu
52. 51
iPlasma
Options in the Group and Property menus change depending on what element is clicked in the
navigation tree tree in the top left.
Group menu options show new children in the navigation tree
Property menu options show new sortable columns
The Group and Property Menus Change
53. 52
iPlasma
Clicking a class will show details about the class, the disharmonies the class is suffering from,
and recommendations of improvements that could be made to it.
Click a Class to Learn More About It
54. 53
iPlasma
Click on an item under Root and then select an option from the Filter menu to filter in (show) only
classes with that property
Filter Menu
55. 54
iPlasma
Pros
Parses source quickly
Open sourced at https://sourceforge.net/p/iplasma-horia/code/HEAD/tree/ (no license specified)
Finds a number of issues in codebase that are not found by other tools
Cons
Older – Parser may not support Java 8 code
Somewhat clunky and not the most intuitive tool to use
Not all features are fully implemented (though most appear to be)
Pros and Cons
56. 55
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
57. 56
The Plan
On an day-to-day basis
• Refactor as you develop – there’s no better time than the present
• Focus on delivering business value for your effort and minimize business disruption
• Don’t refactor all problems.
Only stop work and refactor
• Code that changes frequently
• See Ranking Refactoring Suggestions based on Historical Volatility
http://users.encs.concordia.ca/~nikolaos/publications/CSMR_2011.pdf
or the presentation at
http://www.slideshare.net/tsantalis/ranking-refactoring-suggestions-based-on-historical-volatility
• Code that is bug prone
• It will likely have bugs in the future if not refactored
Coordinate move method & move class refactorings with your team to avoid surprises since these
refactorings may impact a significant number of classes.
What / When Should I Refactor?
58. 57
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
59. 58
If I Had Time
Another tool for identifying Extract Method opportunities, but it doesn’t work
Authors indicated recall and precision was significantly higher than JDeodorant
Project page: http://aserg.labsoft.dcc.ufmg.br/jextract/ (with downloadable source)
Paper: http://homepages.dcc.ufmg.br/~mtov/pub/2014_cbsoft_jextract.pdf
Video: https://www.youtube.com/watch?v=6htJOzXwRNA
JExtract
60. 59
If I Had Time
Analyzes source code commit history and identifies co-change clusters. Idea is that code that
changes together belongs together.
Project site: http://aserg.labsoft.dcc.ufmg.br/modularitycheck/
Source code: https://github.com/aserg-ufmg/ModularityCheck
ModularityCheck
61. 60
If I Had Time
Eclipse plugin that makes software remodularization / class move suggestions:
https://www.sg.ethz.ch/media/publication_files/2014_Modularity_1.pdf
https://sourceforge.net/projects/somomoto/ (plugin doesn’t work in present state) GPL 3 license
From the paper above:
SOMOMOTO
Test case: the remodularization of JGRAPHX (a JAVA
graphical library). The JAVA classes are depicted as circles,
while their color reflects the corresponding package
membership (same color, same package). (a) original. (b)
after remodularization by SOMOMOTO.
62. 61
If I Had Time
Dr. Jehad Delal’s publication Identifying Refactoring Opportunities in Object-Oriented Code: A
Systematic Literature Review
(http://www.isc.ku.edu.kw/drjehad/identifying%20refactoring%20opprtunities%20IST.pdf) lists a
number of papers that discuss refactoring opportunity discovery tools.
Investigate all Papers on Tools
63. 62
1 Your Code Stinks!
2 JDeodorant
3 JMove
4 JSpIRIT
5 Stench Blossom
6 TopicViewer
7 iPlasma
8 The Plan
9 If I Had Time
10 Wrapup
64. 63
Wrapup
Not all tools will detect that the same piece of code needs to be refactored
Not every instance of every detected smell may be a valid one
Be careful that move method & move class refactorings do not introduce cyclic dependencies
There is no substitute for YOU and your experience
Most of these tools will likely move you away from package-by-layer and towards package-by-
feature (which is usually a good thing!)
Keep in Mind
65. 64
Wrapup
JDeodorant: http://users.encs.concordia.ca/~nikolaos/jdeodorant/
Jmove : http://aserg.labsoft.dcc.ufmg.br/software/
JSpIRIT: https://sites.google.com/site/santiagoavidal/projects/jspirit
Stench Blossom: https://github.com/CaptainEmerson/refactoring-
tools/raw/master/installables/update_sites/stench_blossom
TopicViewer: https://dl.dropboxusercontent.com/u/67114006/TopicViewer.rar
My TopicViewer repo: https://github.com/jimbethancourt/topic-viewer
iPlasma: http://loose.upt.ro/iplasma/iplasma.zip
http://www.oreilly.com/programming/free/files/software-architecture-patterns.pdf
Take a Picture of THIS Page
Here the plugin is suggesting that the performAction and the setAction method, along with the action and actionArea member varialbes should be extracted into their own classes.
The colored squares are classes. Squares with the same colors will ideally belong in the same package.
You can also select Activities -> View Results -> Correlation Matrix and select the same file to view the image of the correlation matrix. I’m not sure how to make sense of it, though.