Skip to main content

Benefits of the NS Process

Evolvability​

The code generated by the expandersExpanderA unit of generation that combines a data tree instance (functional M1 model) with a template to generate an artifact. are built based on the NS theory. This theory gives us methods to pinpoint where possible issues might arrive due to new requirements and changes in the future.

These new requirements and changes are not always predictable and in typical projects they often lead to changes all over the project.

By studying these changes combining it with classic stability theory, the NS theory gives a framework to limit these _ combinatorial_ effects.

Decreased Development Cost​

An applicationApplicationThe overarching model container grouping all components, domain logic, and configurations for an enterprise solution. can be described as a combination of concepts and features.

For example, you might have some concepts: Products, Orders and Customers. You then also need some features for each concept: persistence, user interfaces and validations.

To implement this functionality you will need to invest time in the order of:

N (number of concepts) x F (number of features) + C (some additional specific additions)

As your applicationsApplicationThe overarching model container grouping all components, domain logic, and configurations for an enterprise solution. grows, this can become problematic:

  • New features require work to the order of N
  • New concepts require work to the order of F

The expandersExpanderA unit of generation that combines a data tree instance (functional M1 model) with a template to generate an artifact. remedy this situation by generating features based on a model. Concepts are modelled as elements. Features are implemented in expandersExpanderA unit of generation that combines a data tree instance (functional M1 model) with a template to generate an artifact.. The amount of work then becomes:

N (number of elements) + F (number of expanders) + C (custom code)
  • New features require you to write a new expanderExpanderA unit of generation that combines a data tree instance (functional M1 model) with a template to generate an artifact.
  • New concepts require you to model a new element

In addition, you can reuse the work done on expandersExpanderA unit of generation that combines a data tree instance (functional M1 model) with a template to generate an artifact. provided by the framework, as well as work done in other applicationsApplicationThe overarching model container grouping all components, domain logic, and configurations for an enterprise solution.!

Flexibility​

By iteratively modelling, expanding and customizing your applicationApplicationThe overarching model container grouping all components, domain logic, and configurations for an enterprise solution., it becomes simple to adapt to changes:

  • The generated code can be regenerated, unlike code-generators that you run once and then adapt.
  • Generated code is cheap, so adding a new fieldFieldA property of a DataElement expanded to a database column and user interface input element. or element takes little effort for a lot of gain.
  • Likewise, redesigning the model only has effect on the custom code that was added on top of the elements that have now changed.
  • ExpandersExpanderA unit of generation that combines a data tree instance (functional M1 model) with a template to generate an artifact. can be swapped out for other expandersExpanderA unit of generation that combines a data tree instance (functional M1 model) with a template to generate an artifact. through settings and options, making it considerably less painful to switch to different underlying technologies and implementations.

Structure​

Since all applicationsApplicationThe overarching model container grouping all components, domain logic, and configurations for an enterprise solution. are generated with the same expandersExpanderA unit of generation that combines a data tree instance (functional M1 model) with a template to generate an artifact. and every element is generated in a similar way, it the source code gets a very predictable structure. This has several added benefits:

  • The code becomes easier to navigate
  • It easier to get into as a new developer
  • It becomes easier to communicate about aspects of the source code