Home

Overview

Xross editor is a system builder that allows developer composite component in WYSIWYG way. It is a work-life balancer that simplifies development by providing rich components and flexible manipulation. All you need to do is creating flow diagram. Then implementing elegant yet simple component interface at late stage. And the most wonderful thing is all these can be done within IDE, like Eclipse or IDEA.

The diagram is not created just for fun, it is the real system. You can create runnable instance with it using the factory provided. And I know what you may worry about. Unlike other tools, it will not generate lots of helper code based on model file. Instead the factory parses the model file directly and creates instance follows Dependent Injection. In this way it avoid all the code sync and maintain confusion or problems we usually met with code generation.

Also, by separating system building and component implementation, It naturally separates design and implementation stage, breaks down tasks by component and encourages reuse. More benefits are:

1. Allow developer think/work/communicate
   • At component level instead of code level - yes we hate looking at the code,especially others code
   • From biz logic perspective instead of code perspective - a natural result when we level up from code
2. Provide flexible way of system building
   • Rich components: processor, converter, validator, locator
   • Rich structures: chain, if-else, branch, while, do while loop, decorator, adapter
   • Want more flexible, see what happens when placing a component on another one.
   • And don't forget the properties to be specified and categorized
3. Remove the translation from high level design to implementation
   • The diagram is not created for PPT, it is the one that runs in the system
   • Changing the diagram will change the system. Yes, you can now change your system without touch a single line of code.
4. Improve communication efficiency
   • Most developer understand flow diagram, show them these cool diagrams and check out how surprise they are
   • As flow diagram is easy to be explained. Show it to business user like PM, finally your guys have the same language and stay on the same page. :)
   • Still not sure? No problem, with a simple double-click you can jump into code at anytime if people ask for more detail. Perfect!!!

A flow diagram is single-in single-out diagram consists with nodes, structures and links. It illustrate how an incoming request is handled. Any system that follows the IPO (input/process/output) model can be modeled with flow diagram. A system can be as simple as just one diagram with one node, or multiple diagrams if not.

Why flow diagram

The difficulty of using OOAD to represent a system

OOAD is a common way of design and developing system. But it is kind of hard to use and luck skilled designed/developer. reasons are:

1. OOAD is hard to learn. if you look into our production code, you will agree that class/interface design is not performed very well. It is because OOAD is kind of art that needs many years of focused training to polish. In fact, not every developer is good at OOAD.
2. Class diagram is not good at representing system from dynamic perspective. Looking at class diagram is kind of hard to understand the dynamic characters of the system. What developer wants is who does what at when, but class diagram show him just the dependency of each entity
3. Sequence diagram has the same issue. Looking at sequence diagram is kind of hard since it is good at describing one particular processing, but is not good at describing branching, looping by nature

The advantage of flow diagram

There are the following:

1. Easy to communicate. It is very clear to show who does what at when (path). You don't need years of training (like reading class diagram) to understand it. it is also good to be used to communicate with PM, QA or even end user
2. Encourage focusing on domain need. By using xross editor, you have a good start. It already finished most of the system level class design. Developer can use the predefined components to build the system framework freely. That will save time and let developer focus on domain specific design. Refer to below section for those pre-defined interfaces.
3. Verify the system JIT. With default implementation, you can build and run your system in a second.

Components

A node represents a single step which focus on do what. E.g. "convert input" or "create HTML". It can be:

1. Primary node: a class that implements processor, converter decorator, validator or locator interface.
2. Reference node: a reference to another flow diagram or node.

A structure represent a complex node that combine several nodes together.

1. Chain node: a container that contains several nodes or structures. They will be invoked one by one as the defined sequence
2. Bi-Branch node: one validator node and two nodes, the valid node and invalid node. the validator will decide which node to invoke
3. Branch: on locator node and several node. the locator will decide which node to be invoked
4. Pre-validating loop: the while loop
5. Post-validating loop: the do-while loop
6. Decorator: additional processing before and after decorated unit be called
7. Adapter: change the adapted unit to another type

How to use it:

1. build you system with the editor
2. save the model file
3. in your java code, create the system based on the model file with the xross factory class
4. use the system you just created with the input

Checkout more

Design and coponentrs instruction

Editor Usage

Integration Guide

Application and Feedback

Guideline

Deme project