Showcase

Components, Associations

A component can be any type of significant item. For example: a class, a method (in Java, C++, JavaScript, PHP or any other language), an HTML page, a Spring framework bean, etc. It can be a piece of code, an XML element, or in some cases, it can be implicit.

An association is a connection between two elements. For example: a class which extends another class, a method invoking a method, an anchor on an HTML page which forwards to another page or a Spring framework bean using another bean. Associations can be implicit, too, such as the naming conventions used in Ruby on Rails.

One central repository

nWire brings a fresh approach - one central repository holding all the components and associations regardless of their type. There are many tools out there for code and configuration analysis. However, none of these tools stores all the information in one unified manner. Therefore enabling you to view the full picture of your system.

Tools

In addition to the repository there are currently 2 tools: the navigator and the visualizer. Both tools tap into the repository, presenting the information in a user-friendly manner. Although the repository is unified, the view can be customized for each type of association and component. For example: method invocations will be shown with line numbers while class extensions, which are unique, will not show any.

Meta-data driven

Meta-data is the data describing the data (see this great article on the subject). It's like the relation between a class and an an instance, an object. In nWire, for example, a component is considered data and the component type is meta-data. nWire contains a powerful meta-data engine, which employs configuration to control the analysis and presentation or components and associations. This makes it very easy to add more types of components and associations, including new application frameworks and new programming languages. In the current version, the meta-data is not user configurable. This may change in future versions.

More programming languages and application frameworks

The ability to analyze Spring configuration files is planned for the final release of nWire. Expect more frameworks in the future like JEE. We will also support more languages including JavaScript, PHP, Ruby on Rails and other. nWire will be the first tool to combine the knowledge from all frameworks and languages, making it the perfect tool for compound applications.

Custom application frameworks

Many organizations build their own custom application frameworks. The goal is to provide a tool that can be configured to analyze and display the information from such frameworks, alongside the standard information. This will be achieved, in most cases, using plain configuration, without a single line of code.

More tools

The tools provided today are just the tip of the iceberg. We have many great ideas for improvements and additional tools, like advanced filters, custom views, validations and more visualization forms. There is a lot you can do once you have all the application components and associations in one repository.

Anyone who writes or reads code will benefit

nWire assists the coding process. It is used on a daily basis by all developers, team leaders, technical designers and architects. It makes it easier to find code and browse through it. It is an integral part of your IDE, whether you are writing new code, fixing or adding to existing code or just reading code.

Accelerate and streamline the coding process

Software development today is much more than writing a straight piece of code. The code is spread over multiple classes interacting with each other and interfacing with many other classes already written. Developers are productive when writing code, but in the current situation they spend a lot of time finding their way through the different components. nWire reduces the overheads by putting all relevant classes just a few clicks away.

Better code understanding

Modern applications, based on object-oriented languages, are usually built according to a given architectural approach (e.g. n-tier architecture), using various common design patterns. This means the application is built using many small and simple building blocks. Understanding a method is usually not an issue, since the code is kept simple. The challenge is understanding how the single component fits within the application architecture. This is where nWire comes into play.

Improve software quality

When developers understand the code and the architecture they are less likely to make mistakes. Some of the worst bugs in software are architectural bugs: writing code which does not comply with the product architecture. Such code may appear to be working, but will usually fail later, when it is far more expensive to fix. nWire reduces such bugs as the developer can immediately see where his code fits in to the global structure.

Reduces outsourcing costs

When outsourcing a task or hiring temporary external developers, you want to get results fast. The new developers need to understand how the module they are working on connects to the rest of the application. nWire shortens the process, thus saving you money.

Shortens the learning curve for new developers

When introduced to existing large applications, new developers will usually take up to 6 months to start being truly productive. During their training process they will require mentoring, which means they will occupy more developers from your team, and they will probably cause some damage. nWire assists the developer in understanding the existing code and architecture, making it easier to understand examples and correctly write new code which integrates with the existing application.

nWire Analyzer

Thorough analysis of Java code

The analyzer reads the application code and extracts all relevant components and associations. It starts with basic associations such as extension and implementation and digs deeper to associations like method invocation and field access, with a distinction between read and write access.
Includes implicit associations. For example: class which implements multiple interfaces. This includes interfaces which are not implemented directly, but may still be extended by other interfaces that the class implements.

Non-blocking operation

The analyzer works behind the scenes while you code inside Eclipse™. It does not delay your compilation and build process. It supports both automatically and manually built projects. It can also detect changes made outside Eclipse™ and analyze the files as required.

Local data repository

Data is kept locally on the user's machine in a temporary storage. It can always be built from scratch if needed.

nWire Navigator

Show all the components and associations

The navigator presents the components and associations which were discovered by the analyzer. It starts from a given component and shows all associated components. This includes inbound and outbound associations.

Unique Multi-Column View

The column view presents the relevant information on the current column. Click on a relevant item and immediately get the information on the item in the next column. You can open as many columns as required.

Self-adjusting View

The associated components may be presented inline, using a tree-like structure or in the next column. The view adjusts according to the number of associated components. For example: in method invocations, where a method may invoke a given method several times, the line number is also presented.

Synchronized with the editor

The navigator is synchronized with the editor in a two-way synchronization. When you work in the editor, the navigator will follow your cursor as you work on the code and present the relevant information for the current location. When you browse through the navigator components and select a component or association, the navigator will focus your editor on the most relevant location. The synchronization may be switched on or off at any time.

See some navigator screenshots...

nWire Navigator Search

Search for components by name or a partial name using wild cards.
Incremental search - start typing and receive immediate results.
Components include classes and interfaces, methods and fields. This is extremely useful when looking for a specific method.

See some search screenshots...

nWire Visualizer

The visualizer presents the application components and associations in a graphical representation. Each component appears as a node and associations appear as edges. When there are many associations of a given type, the associations are grouped into a sub-node. The graph can be traversed: expanding nodes to reveal associated components while the layout automatically adjusts.

The visualizer can be initialized from the navigator view: click on the visualize button in the navigator and the visualizer will show the current components, graphically.

See some visualizer screenshots...

General Features

Tight integration with Eclipse™

nWire is built for Eclipse™ from the ground up. It is designed according to Eclipse™ standards and works in conjunction with the core Eclipse™ plug-ins like JDT (Java Development Tools).

Non-intrusive approach

nWire is an assistive tool. Its' goal is to improve the coding process. It does not modify the original source files or projects and does not require new skills.

Just Works

nWire is designed to bring true value from the moment you start using it. There's no need to configure or customize the tool. It just works.

Simple. Period.

At nWire Software we put simplicity first. True, there are tons of features planned for future releases, but above all, the goal is to keep nWire a simple tool to use and operate.