JDeodorant is an Eclipse plug-in that identifies design problems in software, known as bad smells, and resolves them by applying appropriate refactorings.

JDeodorant employs a variety of novel methods and techniques in order to identify code smells and suggest the appropriate refactorings that resolve them. For the moment, the tool identifies five kinds of bad smells, namely Feature Envy, Type Checking, Long Method, God Class and Duplicated Code.

Feature Envy problems are resolved by appropriate Move Method refactorings. Type Checking problems are resolved by appropriate Replace Conditional with Polymorphism and Replace Type code with State/Strategy refactorings. Long Method problems are resolved by appropriate Extract Method refactorings. God Class problems are resolved by appropriate Extract Class refactorings. Duplicated Code problems are resolved by appropriate Extract Clone refactorings.

The tool is the outcome of the research performed in the Software Refactoring Lab Department of Computer Science and Software Engineering, Concordia University, Canada and the Software Engineering Group at the Department of Applied Informatics, University of Macedonia, Thessaloniki, Greece.

JDeodorant encompasses a number of innovative features:

• Transformation of expert knowledge to fully automated processes
• Pre-Evaluation of the effect for each suggested solution
• User guidance in comprehending the design problems
• User friendliness (one-click approach in improving design quality)

JDeodorant YouTube Channel
Refactoring of the Clones - Teaser Trailer
Code Smell Visualization Demo

Latest features:

• JDeodorant Release Information on GitHub
• [11/11/2016] Bug fixes and improvements: - Extract Class Refactoring implementation tested with 1475 refactorings applied in JFreeChart-1.0.19 and 1149 refactorings applied in JFreeChart-1.0.10 - Move Method Refactoring implementation tested with 99 refactorings applied in JFreeChart-1.0.19 and 65 refactorings applied in JFreeChart-1.0.10 - Extract Class and Move Method candidate refactorings are no longer virtually applied. This makes the detection of refactoring opportunities much faster. - Redundant Extract Method refactoring opportunities are no longer reported by eliminating identical slices expanding in different blocks.
• [12/09/2016] Bug fixes and improvements in the Move Method Refactoring implementation.
• [29/08/2016] Bug fixes and improvements in the Clone Refactoring feature.
• [14/06/2016] Proper creation of incoming control dependence for Try statements without resources.
• [11/06/2016] Bug fixes and improvements: - Fixed the check for unprocessed methods in call graph analysis. - Fixed an infinite loop in call graph analysis. - TypeSearchRequestor excludes anonymous types from the results when searching for subclass types.
• [09/06/2016] Bug fixes and improvements: - Improved the detection of method declarations with a type parameter from method invocations. - Fixed a common bug in Extract Class and Move Method refactorings related to Enums. - Refactored the common logic for finding topics to class TopicFinder. - Added a right-click pop-up menu to show the code smell visualization on user demand. - Added a check box for the filtering of clone groups based on the Java files currently opened in the editor.
• [06/04/2016] Extended method call analysis to class instance creations and constructor invocations.
• [22/02/2016] Fixed all the bugs reported for Type-Checking related refactorings in the paper by Francesca Arcelli Fontana, Marco Mangiacavalli, Domenico Pochiero, and Marco Zanoni titled On experimenting refactoring tools to remove code smells. Special thanks to Marco Mangiacavalli for the detailed report he prepared.
• [11/02/2016] Fixed all the bugs reported for Extract Method Refactoring in the paper by Francesca Arcelli Fontana, Marco Mangiacavalli, Domenico Pochiero, and Marco Zanoni titled On experimenting refactoring tools to remove code smells. Special thanks to Marco Mangiacavalli for the detailed report he prepared.
• [01/02/2016] Improved the performance of method call analyzer. If the type of the reference through which a polymorphic method is called can be statically determined, then only the overriding implementation of the subclass type corresponding to the reference type is analyzed.
• [21/01/2016] - Improved the views for Feature Envy, God Class, Long Method, Type-Checking by allowing the user to apply refactoring opportunities on the currently examined project, even if the user has selected another project in between. The active project is always the last project on which a detection of code smells has been performed. - If the user has opened multiple code smell views, and each one of them contains refactoring opportunities for a different project, then a change to one of the projects will disable the "Apply Refactoring" button only for the code smell view corresponding to the changed project.
• [15/01/2016] The Extract Method refactoring opportunities in which the statement declaring the variable criterion is nested in a deeper level compared to the level in which the extracted method invocation will be placed (i.e., the level in which the first statement of the slice is nested) are automatically excluded from being reported.
• [08/01/2016] - The project is always being built before getting parsed. AST parsing takes place only if there are no compilation errors. - Files generated by Parser generators are automatically skipped from the analysis for refactoring opportunities. Currently, JavaCC, ANTLR, JFlex, and CUP generators are supported.
• [29/12/2015] Fixed all the bugs reported for Extract Class Refactoring in the paper by Francesca Arcelli Fontana, Marco Mangiacavalli, Domenico Pochiero, and Marco Zanoni titled On experimenting refactoring tools to remove code smells. Special thanks to Marco Mangiacavalli for the detailed report he prepared.
• [14/12/2015] Improved the handling of block nested within control statements in the generation of the Program Dependence Graph.
• [12/12/2015] Improved the clone statement mapping process to prevent the mapping of statements being nested in the same level, but belonging to different basic blocks.
• [06/12/2015] Methods belonging to test classes are no longer reported as refactoring opportunities for Feature Envy. Fixed a bug occurring when the user is switching between the Duplicated Code view containing imported clones belonging to project X and the Refactoring of duplicated methods selected in the Package Explorer belonging to project Y.
• [23/11/2015] The repeated clone groups and class-level clones are no longer stored in memory.
• [20/11/2015] The Duplicated Code view is updated after a refactoring or any other source code edit to highlight the eliminated, edited, and shifted clones. In this way the user does not have to import new clone detection results after the application of a clone refactoring.
• [03/11/2015] The import of clone detection results has become faster by disabling the resolution of bindings when configuring the JDT ASTParser.
• [27/10/2015] Fixed NullPointerException taking place when the default constructor is called, but no such constructor declaration exists in the actual source code.
• [20/10/2015] Bug fix in the parser for CCFinder clone detection results file.
• [17/10/2015] Added a Clone Import Wizard supporting the import of clones from 5 popular clone detection tools, namely CCFinder, ConQAT, Deckard, NiCad, and CloneDR. To use this feature go to Bad Smells -> Duplicated Code. This will open the "Duplicated Code" view for displaying the imported clone groups. Next, select a Java project from the Package Explorer, and click on the "Import Clones" button of the view.
• [19/09/2015] Tons of bug fixes in Extract Clone Refactoring.
• [20/08/2015] - Updated the detection of type-check elimination opportunities to support state variables having java.lang.String as type. - Fixed the case where the classes of the inheritance hierarchy belong to the same CompilationUnit with the code performing the Runtime Type Identification (bug reported by jasyn). - Tons of bug fixes in Extract Clone Refactoring.
• [28/05/2015] The files containing the clones are opened in the editor before refactoring to avoid problems in the Undo history when applying successive Extract Clone refactorings.
• [22/05/2015] Several bug fixes in Extract Clone Refactoring.
• [07/05/2015] Fixed the refactoring of an if/else matched with a conditional expression (ternary operator).
• [30/04/2015] - Excluded interfaces Serializable, Runnable, and Comparable from the list of accepted common super types. - Improved the matching of variable declaration statements with assignment statements.
• [22/04/2015] Extended method commonSuperType() in class ASTNodeMatcher to find also the common superInterface of two types (if there is no common superclass).
• [16/04/2015] Improved precondition for the parameterization of differences to ignore incoming dependencies from advanced matched nodes.
• [26/03/2015] The first stable version of the Control Structure Variant Clone Visualization and Refactoring feature is released.
• [24/12/2014] - Fixed Extract Class Refactoring to make the extracted class implement the Serializable interface, if the source class implements the Serializable interface and at least one extracted field is non-transient. - Fixed the extraction of thrown exceptions in PDG nodes. Class Instance Creations throwing exceptions are also taken into account in addition to method invocations. - Added support for checking whether a method with the same name already exists in a class when performing an Extract Method Refactoring. - Fixed a bug related to the handling of Synchronized blocks during the generation of the PDG.
• [25/10/2014] - The updating of the model is no longer performed asynchronously. This bug caused model inconsistencies when detecting refactoring opportunities in the new code elements introduced by a previously applied refactoring. - Added vertical scrolling to the Slice Profile table. - Added support for collecting comments (i.e., line, block, and javadoc comments) - Fixed the refactoring of clones already containing parameters with argN names (where N is an integer starting from 0) - Fixed a bug in the Extract Method Refactoring mechanics
• [21/09/2014] Updated the slice-profile view to display all local variables declared inside the body of the examined method. Added an option that enables only the variables with a scope covering the entire method body.
• [10/09/2014] Fixed the refactoring of clones with additionally matched statements coming from the advanced matching of control predicate statements.
• [06/09/2014] Added support for the advanced matching of a VariableDeclaration statement having an initializer with a VariableDeclaration statement not having an initializer + an Assignment statement initializing the declared variable. See screenshots for details.
• [30/08/2014] Several fixes in Extract Clone Refactoring. - Updated the search scope for sub-types using SearchEngine.createStrictHierarchyScope() introduced in JDT 3.6 This update improved significantly the performance of the search for sub-types. - Added support for the advanced matching of different loop structures and if statements with expressions using the ternary operator. This feature was developed by Zackary Valenta as part of his NSERC USRA project.
• [20/07/2014] The first stable version of the Software Clone Visualization and Refactoring feature is released.
• [06/04/2014] - Added support for Synchronized and Labeled statements in Extract Clone refactoring. - Added support for pulling up additional duplicated methods called from the original clones in Extract Clone refactoring.
• [29/03/2014] Fixed the matching of method invocations with method declarations having varargs parameters. - Added analysis support for Enum types. - Added analysis support for Labeled and Synchronized statements.
• [22/02/2014] Clone Visualization bug fixes: a) fixed the matching of InfixExpressions, b) fixed a bug in the highlighting of differences for SimpleTypes.
• [21/12/2013] Improved the matching of method invocations with method declarations to address the cases where 'type parameter names' are replaced with actual types in the method calls.
• [14/12/2013] - Improved the user interface of Extract Clone Refactoring, so that it presents multiple refactoring opportunities from a pair of methods in the same Wizard page (using a combo for allowing the user to select among the different refactoring opportunities). - Added initial support for the mapping of if/else statements with expression statements containing a conditional expression (i.e., the ternary operator condition ? true : false).
• [13/10/2013] - Fixed the handling of additional methods moved along with source method in Move Method Refactoring. - Fixed the processing of if statements within the body of do-while loops in the construction of control flow graphs.
• [06/10/2013] New Clone Visualization and Refactoring (Beta) support. To use the new feature select two methods in the Package Explorer (holding the Ctrl key), right-click on one of the methods, and select "Refactor Duplicated Code..." - All inner types are parsed regardless of their nesting level. - Method calls with varargs are properly handled in method call analysis. - Program Dependence Graph generation has been enhanced with a caching mechanism for internal method calls.
• [02/09/2013] New Code Smell Package Map Explorer for Feature Envy and God Class!! This new visualization allows to explore the detected code smells at system level and discover relationships and dependencies between code smells. The visualization was developed by Kimberly Dextras-Romagnino as part of her NSERC USRA project.
• [02/07/2013] Code Smell Visualizations have been enhanced with auto scrollbar adjustment and zoom support (from the View menu options or by scrolling the mouse wheel).
• [21/06/2013] The binding returned from SimpleName expressions should be checked for NullPointer. Many thanks to Wei Wu (École Polytechnique de Montréal) for reporting the problem.
• [13/06/2013] New Code Smell Visualizations for Feature Envy and God Class!! Whenever you double-click on a refactoring suggestion a View will open displaying a visualization for the corresponding code smell instance. The visualizations were developed by Kimberly Dextras-Romagnino as part of her NSERC USRA project.
• [28/02/2013] Fixed a bug in the construction of control flow graphs. Many thanks to Danny Verloop (TU Delft) for reporting the problem.
• [06/11/2012] JDeodorant was updated to support Union Types introduced in Java 7. Union types are mainly used in the new Multicatch feature.
• [04/11/2012] JDeodorant was updated to support the Java Language Specification 4 (Java 7). This affected the construction of Control Flow and Program Dependence graphs, since try statements may declare resources in JLS 4. More details can be found at the JDeodorant ChangeLog.
• [26/10/2012] Alias analysis in the detection of Extract Method refactoring opportunities (Long method code smell) caused in some cases an infinite recursion. The new implementation of alias analysis improves significantly the performance. This is an important update.
• [09/10/2012] The exclusion of classes containing method with @Test annotations from the analysis may cause NullPointer exceptions (such a case was found in JUnit). As a result, test methods are not excluded from the analysis.
• [28/02/2012] Created a Standalone version of JDeodorant for the detection of refactoring opportunities from Eclipse applications. The results of Type Checking bad smell are now reported in a tree view and are grouped per inheritance hierarchy or named constants.
• [16/11/2011] Added a new precondition for Move Method refactoring. The variable (parameter or field of target class type) through which the moved method will be invoked must not be assigned within the body of the candidate method to be moved.
• [04/09/2011] Fixed the unnecessary importing of nested types in all implemented refactorings.
• [22/04/2011] Several improvements in the identification process and presentation of Extract Class refactoring opportunities. The application of the Extract Class Refactoring has been improved to handle the extraction of static members and the proper initialization of final fields in the extracted class when they are initialized inside constructors. More details can be found at the JDeodorant ChangeLog.
• [15/03/2011] Added a user option in the input pages of the Move Method and Extract Class refactorings allowing to keep delegates to the public moved methods.
• [12/03/2011] Extract Class Refactoring has been implemented from scratch and several bugs have been fixed. Added user rating support for the identified Extract Class refactoring opportunities.
• [09/01/2011] Try/catch blocks and throw statements are handled according to the approach proposed by Allen & Horwitz (2003). Added a rule for the preservation of output dependences. M. Allen, and S. Horwitz, "Slicing Java Programs that Throw and Catch Exceptions", ACM SIGPLAN Workshop on Partial Evaluation and semantics-based Program Manipulation, pp. 44-54, 2003.
• [25/12/2010] The unlabeled break and continue statements within the body of loops and the break statements within the body of switch statements are handled according to the augmented program dependence graph (APDG) approach proposed by Ball & Horwitz (1993), Kumar & Horwitz (2002). T. Ball, and S. Horwitz, "Slicing Programs with Arbitrary Control Flow", First International Workshop on Automated and Algorithmic Debugging, pp. 206-222, 1993. S. Kumar, and S. Horwitz, "Better Slicing of Programs with Jumps and Switches", Fifth International Conference on Fundamental Approaches to Software Engineering, pp. 96-112, 2002.
• [02/12/2010] Fixed a variety of problems related with the Type checking code smell.
• [08/11/2010] Added functionality allowing the user to rate each identified refactoring opportunity with a rating ranging from 0 to 5 stars. The ratings provided by the users will help JDeodorant team to improve the ranking mechanism that sorts the identified refactoring opportunities.
• [27/08/2010] Added support for code smell evolution analysis throughout successive versions of a given Java project. Just select an identified refactoring opportunity from the table view and click on "Evolution Analysis" button. JDeodorant will automatically analyze the evolution of the corresponding code smell in the relevant project versions loaded in the workspace. Eventually, JDeodorant will present a table showing the changes regarding the severity of the code smell among the successive project versions. Watch out the screencast showing the evolution analysis for a Feature Envy code smell.
• [12/07/2010] Added an Update Site for JDeodorant.
• [11/07/2010] The tool supports the identification of Extract Class refactoring opportunities for the decomposition of "God" classes. This feature is the outcome of a joint research effort with the SSRG Lab at the Department of Computing Science, University of Alberta.
• [01/07/2010] The speed of slice computation when constructing unions of slices has been significantly improved.
• [15/06/2010] A flexible calculator for slice-based cohesion metrics. Just right-click on a method from Package Explorer and click on "Slice-based Cohesion Metrics..." from the menu. The calculator will automatically compute the slices for all the variables which are declared within the body of the selected method and visually present its slice profile. The user can enable/disable any variable from the slice profile. The statements which are common to all enabled slices are highlighted in green color. The slice-based cohesion metrics (overlap, tightness, coverage) are dynamically re-calculated after each modification of the slice profile. See the screenshots for details.

tern.js is a stand-alone code-analysis engine for JavaScript written in Javascript. tern.java provides the capability to use tern.js in Java context by using node.js server. Tern Eclipse IDE is Eclipse plugins based on tern.java which extends JSDT JavasScript Editor with tern to improve :

• JavaScript completion
• JavaScript text hover
• JavaScript validation
• JavaScript hyperlink

Tern Eclipse IDE supports a lot of JavaScript framework like :

• AngularJS
• AlloyUI
• CKEditor
• Closure Library
• CordovaJS
• Dojo Toolkit
• ExtJS
• Google Maps
• Grunt
• jQuery
• Liferay
• Meteor
• Node.js
• Qooxdoo
• RequireJS
• YUI Library

If you start with Tern Eclipse IDE, please read Getting Started.

Angular Eclipse is a set of plugins which provide support for Angular:

• it is based on TypeScript IDE for TypeScript support.
• it integrates angular-cli with Terminal, Wizards and Launches.
• it extends WTP HTML Editor to support Angular2 syntax inside the HTML editor.

TypeScript IDE provides 2 main features:

• a TypeScript Editor which provides TypeScript completion, validation hover, etc for TypeScript files (*.ts), JSX files (*.jsx/*.tsx) and even simple JavaScript file since TypeScript 1.8 supports it (Salsa).
• a TypeScript Compiler to compile on save, or build on save TypeScript *.ts/*.tsx files to emited *.js/*.js.map files

JavaScript Build Eclipse is a set of plugins based on tern.java which gives support for Grunt and Gulp (and more?). It provides the Build Explorer view which looks like the Ant view. The Build Explorer displays in a tree the tasks : With the Build Explorer, you can : * `display in a tree, tasks and targets from Gruntfile.js / glupfile.js. * `execute task/targe` with Eclipse launch by double clicking in the task / target item of the tree. * `navigate to the definition of a task or target`: opens the Gruntfile.js / glupfile.js and selects the location where task/target is declared. To collect tasks / targets from Gruntfile.js / glupfile.js, tern.java is used : * tern-grunt : a tern plugin which adding support for Grunt. * tern-gulp : a tern plugin which adding support for Gulp. Those tern plugins are used too for JavaScript editor completion :

AngularJS Eclipse Plugin provides support for Angular 1. It extends Eclipse WTP to :

• provides an HTML editor which supports AngularJS expression and directive. See HTML features for more informations.
• provides an Angular Explorer view which displays modules, controllers of your project in a tree.
• provides a Javascript editor which supports AngularJS features (modules, etc). See Javascript features for more informations.

AngularJS Eclipse is based on tern.java to manage powerfull completion on HTML files (AngularsJS Expression, directive, modules) and Javascripts files (see Tern Eclipse IDE) If you start with AngularJS Eclipse, please read Getting Started.

A new solution to Protect Java App from Decompilation by encrypting the classes.

Support JavaSE App, Tomcat Web App, Spring Boot App, GlassFish App, Payara App and Java 8, Java 11 Environment.

Guide of installation: https://doc.protector4j.com/eclipse-plugin

Documention: https://doc.protector4j.com/get-started

For further information: https://protector4j.com

The Groovy Development Tools (GDT) provides Eclipse and Maven (m2e) support for the Apache Groovy programming language. GDT adds full-featured IDE support including editors, wizards, content assist, debugging, refactoring and searching.

The GDT requires the Eclipse Java Development Tools (JDT) as it builds upon Java/JVM support, including Java interoperability (bi-directional dependencies via joint compilation). If your Eclipse flavor does not include JDT, you must install it first.

GDT does not provide any direct support for Grails. If you want Grails tooling, then please consider Groovy-Grails Tools Suite or spring-projects/grails-ide for your Grails projects.

The plantuml library implements a DSL and renderer for many UML diagrams (class, sequence, objects, states, activities, …). See http://plantuml.com for more info about the DSL and renderer.

This project integrates plantuml’s functionality into Eclipse, by means of a view that shows a diagram for the currently active editor. The rendered diagram is typically based on explicit DSL code embedded in the editor, or generated from the content of the editor.

We currently support generating diagrams for

• DSL code embedded in text in any text editor
• the class in the Java and Class File editors, based on the Eclipse Java model
• the EClasses in Ecore models in the Ecore editor

There’s also experimental support for generating a diagram for all the Java classes in a Java project (or within one or more Java packages).

Diagram generation is handled by (implementations of) an extension point, so you can customize the process of generating a diagram for other file types or editor content.

Design and Verification Tools (DVT) is an integrated development environment (IDE) for the design and verification engineers working with SystemVerilog, Verilog, VHDL, e, UPF, CPF, SLN, PSS, SDL. Including Universal Verification Methodology (UVM) support. It is similar to well-known programming tools like Visual Studio®, NetBeans®, and IntelliJ®. DVT comprises a proprietary IEEE standard-compliant parser, a smart code editor, an intuitive GUI, a comprehensive set of features that help with code inspection, navigation, documentation, and debugging, and an innovative linting framework. DVT allows design and verification engineers to overcome the limitations of plain text editors and use a modern and powerful tool that enables them to:

• Increase the speed and quality of new code development
• Easily understand complex or poorly documented source code
• Simplify the maintenance of legacy code and reusable libraries
• Accelerate language and methodology learning
• Automatically generate well-organized source code documentation

FEATURES Some of the features that DVT offers include:

• Compilation errors signaled on the fly
• Autocomplete / Content Assist
• Customizable code and project templates
• Dedicated wizards to generate getters and setters, override functions, or help with UVM factory registration
• Hyperlinks
• Semantic Search and Show Usages
• Quick fixes / Autocorrect
• Refactoring
• Macro expansion
• Project database query views (types, macros, checks, etc.)
• Structural views (type hierarchy, design hierarch, call hierarchy, etc.)
• Signal tracing
• UML and TLM diagrams for inspecting and documenting the verification environment
• Schematic, trace, state machine diagrams for inspecting and documenting the design
• Dedicated UVM support
• Cross-language capabilities for mixed-language projects
• In-line reminders for task tracking (TO DOs)
• Vi and emacs emulation

INTEGRATION WITH OTHER TOOLS Since it is built on the Eclipse Platform, the DVT IDE can be easily integrated within a large plug-in ecosystem. It also integrates seamlessly with all major hardware simulators such as NCSim , Specman , VCS , and Questa, to enable simplified simulation analysis and debugging. In addition, it works with revision control systems like CVS, Git, Subversion, ClearCase and bug tracking systems such as Bugzilla and ClearQuest.
RESOURCES

• DVT Eclipse IDE Web Page
• DVT Eclipse IDE Datasheet
• Demo movies
• DVT Debugger Add-on

Palladio is a software architecture simulation approach which analyses your software at the model level for performance bottlenecks, scalability issues, reliability threats, and allows for a subsequent optimisation. Palladio requires neither buying expensive executions environments (servers, networks, or storage) nor fully implementing a software product. Construction rules are automatically checked by Palladio and thus allow optimal software architectures without costly trial-and-error-cycles. Like in other engineering disciplines, Palladio enables software engineers to construct software straight and in the right way. Use Palladio to

• Forecast the impact of your design decisions
• Lower the costs for trial-and-error-cycles
• Build highly reliable, scalable, and resource-efficient software architectures

The Palladio Component Model is implemented using the Eclipse Modeling Framework (EMF). We have implemented an integrated modelling environment (called Palladio-Bench) based on the Eclipse IDE. It enables developers to create PCM model instances with graphical editors and derive performance metrics from the models using analytical techniques and simulation. The best way for getting started with the Palladio-Bench is looking through the screencasts and tutorials provided on the webpage. The project community is managed by project leads of: the Karlsruhe Institute of Technology (www.kit.edu), the FZI - Research Center for Information Technology (www.fzi.de), and Chemnitz University of Technology (https://www.tu-chemnitz.de/)

Install on Eclipse IDE to get advanced Java code completions

Codota completes lines of code based on millions of open source Java programs and your context helping you code faster with fewer errors.
The following features are available with the new version of Codota:

• Full line AI autocomplete
• In line and relevant code examples
• Code suggestions based on your own coding practices

Your code stays private. Codota doesn't send your code to the Codota server, we only send minimal contextual information from the currently edited file that allows us to make predictions based on your current local scope. Learn more.

Installation is quick and simple, just follow the instructions here
Go to our website to find popular Java code like Java date format snippets and Java timer examples
Click here for more information.

Terms & Conditions
Contact support@codota.com for any question or issue.
Supports Eclipse Mars or higher

Plugin adding Markdown text-editing support to Eclipse. Makes editing text files in Eclipse a lot better. Markdown is a simple and intuitive text format syntax that lets you get rich formatting with 'normal' text.

Features:

• Document outline (including an easy to use document structure editor)
• Folded sections
• Preview
• Export-to-html
• Task tags
• Word-wrapping
• Paragraph formatting.

History:
v1.0 - associate with .mdown, .markdown - fix NPE for <> style links in Kepler 4.3.1
v1.1 (24 Feb 2014) added code Rule by @tbrugz Telmo Brugnara - open Preferences icon on View toolbar
v1.2 (Jan 2015) by Olivier Martin @oliviermartin #52 - Update preview when the file is saved #48 - MultiMarkdown metadata #49 - GitHub code blocks #50 - detecting links #51 - open GFM View from Markdown View #53

New update site: https://nodeclipse.github.io/updates/markdown/
Old update site: http://www.winterwell.com/software/updatesite/

Check sources on GitHub https://github.com/winterstein/Eclipse-Markdown-Editor-Plugin and give us a star!

Listed in Nodeclipse Plugins List

MARBLE™

MARBLE™ (Modernization Approach for Recovering Business processes from LEgacy Systems) is a framework that focuses on the reverse engineering stage in the horseshoe modernization model to obtain business processes from legacy information systems. KDM is the core of MARBLE™, since it enables the representation and management of knowledge extracted by means of reverse engineering from all the different software artifacts of the legacy system in an integrated way. Then, that legacy knowledge is gradually transformed into business processes. For this purpose, MARBLE™ is divided into four abstraction levels with three transformations among them.

Download

• Level L0. This level represents the legacy information system in the real world, and is the source system to recover underlying business processes.
• Level L1.This level represents several specific models, i.e., one model for each different software artifact involved in the archaeology process like source code, database, user interface, and so on. These models are considered PSM models since they depict the software artifacts according to their specific technology platforms.
• Level L2. This level consists of a single PIM model that represents the integrated view of the set of PSM models in L1. The KDM metamodel is used for this purpose, since it makes it possible to model all the artifacts of the legacy system in an integrated and technological-independent manner. Firstly, we say that L2 is obtained in an integrated way because L2 works as a KDM repository that can be progressively populated with knowledge extracted from the different information systems of an organization. This is due to the fact that the structure package at the last KDM abstraction layer (c.f. Section 2.2) allows representing different systems, subsystems, components, architecture view, and so on. This is a key advantage because business processes are usually executed by multiple systems within an organization. Secondly, we say that L2 is represented in a technological-independent way due to the fact that KDM standard abstract (from the program element layer, the second layer of the KDM metamodel) all those details concerning the technological viewpoint (e.g. the program language). Thereby, the KDM repository at L2 can represent several legacy information systems even when their program languages or platforms are different.
• Level L3. This level depicts, at the end of the archaeology process, the business processes recovered from the legacy system that is fully represented by a KDM model in L2. The business process model in L3 represents a CIM model of the system.

The three generic transformations between the four abstraction levels proposed in MARBLE™ are the following:

• Transformation L0-to-L1. This transformation obtains PSM models from each legacy software artifact. Classical reverse engineering techniques such as static analysis, dynamic analysis, program slicing and dicing, formal concept analysis, subsystem decomposition, and so on, could be used to extract the knowledge from any software artifact and build the PSM model related to it. These PSM models are represented according to specific metamodels. For example, a Java metamodel may be used to model the legacy source code, or an SQL metamodel to represent the database schema, etc.
• Transformation L1-to-L2. The transformation between levels L1 and L2 consists of a set of model transformations to obtain a PIM model based on the KDM metamodel. This PIM model is built from the PSM models from level L1. The L1-to-L2 transformation can be implemented by means of QVT. The transformation from the legacy information system (L0) to the KDM model (L2) is not direct due to the fact that, in many cases, the platform-specific knowledge in the intermediate level L1 might be used to infer more business knowledge. Thus, the semantic gap between the legacy system and its KDM model is reduced incrementally through L1.
• Transformation L2-to-L3. This transformation is based on a set of patterns. When a specific structure is detected in the KDM model from level L2, each pattern indicates what elements should be built and how they are interrelated in the business process model in L3. This is known as pattern matching and can be implemented in MARBLE™ by means of QVT relations, the declarative part of the QVT language. In addition, this last transformation can be assisted by business experts who know the organization. The external information provided by experts also serves as valuable knowledge in business process archaeology. Experts can determine inconsistent or incoherent fragments in the preliminary business process models obtained after pattern matching; they can refactor the business process models, and incrementally fit the process models to the real behavior of the organization. Moreover, this transformation supports the representation of several subsystems at the same time. This transformation structures subsystems as different pools and lanes in the process model. Lanes and pools, which represent BPMN sub-modules, are related between them by means of certain data objects. These data objects are written by a sub-module and are read by another sub-module (e.g. data stored in a database by a subsystem and loaded by other subsystem; or a subsystem invoking a service of another one). Moreover, not all parts of business processes are executed by legacy information systems, i.e., there are a lot of manual business activities. Manual business activities can be also added by final business expert intervention. Since we are proposing an automated approach, the treatment of that kind of activities is beyond of the scope of this work. Other techniques address challenges like identifying human activities in the legacy system, activities outside the legacy system, identifying roles, and so on.

The main objective of MARBLE™ is to provide a first version of business process models that, compared with business process redesign by business experts from scratch, represents a more efficient solution and a good start point to achieve business process archaeology. In addition, the business process redesign by experts from scratch might discard meaningful business knowledge that is only present in legacy information systems. Anyway, MARBLE™ supports the addition and integration of manual business activities together the discovered business processes. For this purpose, MARBLE™ defines a finite set of operations that business experts can carry out in the business processes at the end of the automate part of our method.

MARBLE™ is defined as a generic framework to rebuild business processes because it defines the organization of the four abstraction levels as well as the guidelines to perform the three transformations between them. However, this generic framework must be instantiated for each kind of program language on which the system is based, for each reverse engineering technique that is considered to extract the legacy knowledge, and so forth. The following subsections depict the three specific transformations that show how the business process archaeology is carried out.

If you ever wondered, Eclipse has project for TCL inside DLTK (Dynamic Languages Toolkit) project. You can install it any time from Eclipse update site or using Install button or in Marketplace client.

IBUPROFEN (Improvement and BUsiness Process Refactoring OF Embedded Noise) is a framework with which to refactor business process models retrieved particularly by reverse engineering from existing information systems. IBUPROFEN is specially designed for business process models represented according to the BPMN (Business Process Modeling Notation). IBUPROFEN allows different refactoring operators to be applied as well as the assessment of several measures related to the modifiability and understandability of business process models. Sor far, IBUPROFEN provides a set of ten refactoring operators grouped into three categories: relevant elements maximization, fine-grained granularity reduction and completeness. IBUPROFEN has been implemented as an EclipseTM plug- (Download) and it can therefore be used in combination with other Eclipse™ plug-ins aimed at obtaining business process models from the source code of existing information systems.

• A demonstration of the IBUPROFEN tool can be seen here

Snyk is a free security vulnerability scanner that tests your project's open source dependencies, finds and helps fix security issues in your Eclipse workspace projects.

You can use Snyk on your Java, Scala, JavaScript .Net, Ruby projects and many more! Each scan tests your application against Snyk's extensive vulnerability database, to identify and advise you how to fix security problems. To learn more, visit http://snyk.io

Modern Ruby plugin combining the powers of the Eclipse IDE and the Solargraph language server!

Currently supported features:

• Rich syntax highlighting
• Code completion
• Rename refactoring
• Find references
• Jump to declaration
• Code outline
• Code folding
• Documentation hovers, see the Solargraph readme for more information
• Run files as Ruby programs
• Run bundle install on Gemfiles and gem build on gemspec files
• Various other features part of the Language Server Protocol

Support the project by starring the plugin on the marketplace and on GitHub!

Create highly customisable notes in Eclipse and never lose track of your thoughts, ideas or code snippets!

• Create as many notes as you like in a dedicated Eclipse view.
• Modify the text style (font, color, bold, italic, underlined, strikeout, etc.).
• Customise the appearance and functionality of the plugin via its preference page.
• Create lists of text elements.
• Automatically save the contents of your notes to a default or custom location.
• Use editable shortcuts to boost your productivity.
• Export notes as text files.
• Lightweight and user-friendly interface.
• Source code fully available.
• More to discover and to come in future updates!

Notepad4e is free, without ads and open-source. Support the project by starring it on the marketplace and/or on GitHub!

Epsilon is a family of languages and tools for code generation, model-to-model transformation, model validation, comparison, migration and refactoring that work out-of-the-box with EMF and other types of models. Epsilon has been an official Eclipse project since 2006 and has a substantial user base (see http://www.eclipse.org/epsilon/users/).